NVIDIA Scene Graph Software Development Kit (NVSGSDK)

Version:
NVSGSDK v2.1.1.10

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.

Contents

Getting Started

  • 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
  • NVSG Core Classes
  • NVSG Objects
  • Working with Lights
  • Working with State Attributes
  • Traversers
  • Working with Traversers
  • Memory Management

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

Legal

  • NVSG License Agreement
  • Legal Notice

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

Generated on Fri Aug 4 08:32:59 2006 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]
AnalyzeTraverser.h [code]
AnimatedQuads.h [code]
AnimatedTransform.h [code]
AnimatedTriangles.h [code]
Animation.h [code]
AnimationManipulator.h [code]
AppTraverser.h [code]
Assert.h [code]
Billboard.h [code]
Bitmap.h [code]
BitMask.h [code]
BlendAttribute.h [code]
Camera.h [code]
CgFx.h [code]
CullData.h [code]
CullTraverser.h [code]
DAL.h [code]
DbgNew.h [code]
DepthAttribute.h [code]
DestrippingTraverser.h [code]
DirectedLight.h [code]
Drawable.h [code]
ErrorHandling.h [code]
Face.h [code]
FaceAttribute.h [code]
FlightCameraManipulator.h [code]
FramedAnimation.h [code]
FrustumCullTraverser.h [code]
GeoNode.h [code]
GeoNodeCombineTraverser.h [code]
GeoNodeUnifyTraverser.h [code]
GLCgGLStateCallbacks.h [code]
GLContext.h [code]
GLDALData.h [code]
GLFunctions.h [code]
GLMFCRAWnd.h [code]
GLObjects.h [code]
GLStatistics.h [code]
GLTraverser.h [code]
GLWinRenderArea.h [code]
glxtypes.h [code]
Group.h [code]
GroupEliminateTraverser.h [code]
HighlightBox.h [code]
HighlightEdges.h [code]
HighlightObject.h [code]
IdentityToGroupTraverser.h [code]
ILTexLoader.h [code]
Incarnation.h [code]
IndependentPrimitiveSet.h [code]
InterpolatedAnimation.h [code]
IOLayer.h [code]
KeyInput.h [code]
LightSource.h [code]
LinearInterpolatedAnimation.h [code]
LineAttribute.h [code]
Lines.h [code]
LineStrips.h [code]
LinuxTypes.h [code]
Lockable.h [code]
LOD.h [code]
LODCombineTraverser.h [code]
LODEliminateTraverser.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]
Mat33f.h [code]
Mat44f.h [code]
Material.h [code]
Matnnf.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]
NormalizeTraverser.h [code]
nv_attribute.h [code]
NVBLoader.h [code]
NVBLoadTraverser.h [code]
nvgl.h [code]
nvmath.h [code]
NVNVB.h [code]
NVNVB2.h [code]
nvsg.h [code]
nvsgapi.h [code]
nvsgcommon.h [code]
NVSGLight.cg
NVSGLoader.h [code]
NVSGMaterial.cg
NVSGSaver.h [code]
NVSGVersion.h [code]
nvsgwindefs.h [code]
nvtraverser.h [code]
nvui.h [code]
nvutil.h [code]
Object.h [code]
OptimizeTraverser.h [code]
ParallelCamera.h [code]
Path.h [code]
PBuffer.h [code]
PerspectiveCamera.h [code]
Pixmap.h [code]
Plane3f.h [code]
PlugIn.h [code]
PlugInCallback.h [code]
PlugInterface.h [code]
PlugInterfaceID.h [code]
PointAttribute.h [code]
PointLight.h [code]
Points.h [code]
PrimitiveAttribute.h [code]
PrimitiveSet.h [code]
PrimitiveSetCombineTraverser.h [code]
PrimitiveSetUnifyTraverser.h [code]
ProblemLog.h [code]
QuadMeshes.h [code]
Quads.h [code]
QuadStrips.h [code]
Quatf.h [code]
RayIntersectTraverser.h [code]
RCObject.h [code]
Registry.h [code]
RenderArea.h [code]
RenderTraverser.h [code]
resource.h [code]
Scene.h [code]
SearchTraverser.h [code]
Shape.h [code]
Singleton.h [code]
SkinnedTriangles.h [code]
SmoothTraverser.h [code]
Sphere3f.h [code]
SpotLight.h [code]
StateAttribute.h [code]
StatePass.h [code]
StateSet.h [code]
StateSetUnifyTraverser.h [code]
StateVariant.h [code]
Loader/ILTexLoader/stdafx.h [code]
Loader/NBFLoader/stdafx.h [code]
Saver/NBFSaver/stdafx.h [code]
StrippedPrimitiveSet.h [code]
StrippingTraverser.h [code]
Switch.h [code]
SwitchToGroupTraverser.h [code]
SWMRSync.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]
TransformCombineTraverser.h [code]
TransformManipulator.h [code]
TransformStack.h [code]
Traverser.h [code]
Triangles.h [code]
TriangulateTraverser.h [code]
TriFans.h [code]
TriStrips.h [code]
Vec2f.h [code]
Vec3f.h [code]
Vec4f.h [code]
Vecnf.h [code]
VertexAttributeSet.h [code]
VertexAttributeSetUnifyTraverser.h [code]
VertexUnifyTraverser.h [code]
ViewState.h [code]
VNVector.h [code]
VRMLTypes.h [code]
WalkCameraManipulator.h [code]
WRLLoader.h [code]
WRLLoadTraverser.h [code]
Generated on Fri Aug 4 08:32:59 2006 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/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 Fri Aug 4 08:33:14 2006 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/Trace.h"
00034
00035 namespace nvutil
00036 {
00038   class Chunk
00039   {
00040     public:
00042       Chunk(size_t blockSize);
00043
00045       bool operator==(const Chunk& rhs) const;
00046       bool operator!=(const Chunk& rhs) const;
00047
00049       void * alloc();
00050       void dealloc(void * p);
00052       void freeMemory();
00053
00055       unsigned char blocksAvailable() const;
00057       bool isUnused() const;
00059       bool isInsideBounds(void * p) const;
00060
00061     private:
00063       enum { numBlocks = 255 };
00064
00066       void init();
00067
00069       void * lowerBound() const;
00070       void * upperBound() const;
00071
00072       unsigned char * m_rawMem; // raw memory
00073
00075       size_t m_blockSize;
00076       size_t m_chunkSize;
00077
00078       unsigned char m_firstAvailableBlock;  // addresses first memory block available
00079       unsigned char m_blocksAvailable;      // total amount of blocks available
00080   };
00081
00083   class FixedAllocator
00084   {
00085     public:
00087       FixedAllocator();
00088
00090       ~FixedAllocator();
00091
00093       void * alloc();
00094
00096       void dealloc(void * p);
00097
00099       void init ( size_t blockSize );
00100
00101     private:
00102       size_t m_blockSize;   // fixed block size
00103
00104       typedef std::vector< Chunk > Chunks;
00105       Chunks m_chunks; // array of chunks
00106
00107       Chunk  * m_lastAlloc;   // last chunk taken for allocation
00108       Chunk  * m_lastDealloc; // last chunk taken for deallocation
00109   };
00110
00111 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
00113
00117   class Allocator
00118   {
00119     public:
00121
00122       Allocator();
00123
00125
00126       ~Allocator();
00127
00129
00130       void * alloc( size_t size
00131                   );
00132
00133 #if defined(_DEBUG)
00134
00135
00137       void * alloc( size_t size
00138                   , const char * src
00139                   , unsigned int ln
00140                   );
00141 #endif
00142
00144
00146       void dealloc( void * p
00147                   , size_t size
00148                   );
00149
00150     private:
00152       void * palloc(size_t size);
00153
00154     private:
00155       // forward to default new/delete operators if block size
00156       // exceeds the threshold given by maxBlockSize
00157       enum { maxBlockSize = 256 };
00158
00159       // provide one allocator for each single size <= maxBlockSize
00160       FixedAllocator m_allocTbl[maxBlockSize];
00161
00162       // leak detection in debug mode
00163 #if defined(_DEBUG)
00164       struct DbgAllocInfo
00165       {
00166         void  * p;            //  memory location
00167         std::string  source;  //  source file of allocation
00168         unsigned int ln;      //  line of allocation
00169
00170         // with this we can simply use a vector for our alloc infos
00171         bool operator==(void * _p) const { return p==_p; }
00172         bool operator!=(void * _p) const { return p!=_p; }
00173       };
00174
00175       std::vector<DbgAllocInfo> m_dbgAllocInfos;   //  vector of allocation infos
00176
00177       //  helper functor to put out a memory leak warning
00178       struct LeakWarning
00179       {
00180         void operator()(const DbgAllocInfo& allocInfo) const
00181         {
00182           std::string str;
00183           char cPtr[sizeof(void*)*2+1];
00184           sprintf(cPtr, "%p", allocInfo.p); // cast to a hex-string for pointers
00185           char cLine[20];  // enough for 64-bit integers even
00186           sprintf(cLine, "%d", allocInfo.ln);
00187
00188           str = "****Memory Leak Detected*** Source: ";
00189           str += allocInfo.source;
00190           str += ", Line: ";
00191           str += cLine;
00192           str += ", Ptr: 0x";
00193           str += cPtr;
00194           str += "\n";
00195           traceDebugOutput()(str.c_str());
00196         }
00197       };
00198 #endif
00199 #if defined( ALLOCATION_COUNTER )
00200       std::map<size_t,size_t> m_allocSizeMap;
00201 #endif
00202   };
00203
00204   inline void * Allocator::alloc(size_t size)
00205   {
00206     NVSG_ASSERT(!"WARNING: Bypassing leak detection in debug mode!\n");
00207     return palloc(size);
00208   }
00209
00210 #if defined(_DEBUG)
00211   inline void * Allocator::alloc(size_t size, const char* src, unsigned int ln)
00212   {
00213     DbgAllocInfo allocInfo;
00214     // collect allocation info for memory leak detection
00215     allocInfo.p = palloc(size);
00216     allocInfo.source = src;
00217     allocInfo.ln = ln;
00218     m_dbgAllocInfos.push_back(allocInfo);
00219     return allocInfo.p;
00220   }
00221 #endif
00222
00223   inline void Allocator::dealloc(void *p, size_t size)
00224   {
00225 #if defined(_DEBUG)
00226     m_dbgAllocInfos.erase(std::remove(m_dbgAllocInfos.begin(), m_dbgAllocInfos.end(), p), m_dbgAllocInfos.end());
00227 #endif
00228     if ( size <= maxBlockSize )
00229     {
00230       m_allocTbl[size-1].dealloc(p);
00231     }
00232     else
00233     {
00234       ::operator delete(p);
00235     }
00236   }
00237
00238   inline void * Allocator::palloc(size_t size)
00239   {
00240 #if defined( ALLOCATION_COUNTER )
00241     m_allocSizeMap[size]++;
00242 #endif
00243     // use suitable allocation for given size
00244     return (size<=maxBlockSize) ? m_allocTbl[size-1].alloc() : ::operator new(size);
00245   }
00246 //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
00247
00249
00255   class IAllocator
00256   {
00257     public:
00259       typedef Singleton<Allocator> theAllocator;
00260
00262
00264       IAllocator() {}
00266       virtual ~IAllocator() {}
00267
00269
00271       NVSG_API void * operator new( size_t size // Size in bytes of demanded memory block.
00272                                   );
00273 #if defined(_DEBUG)
00274
00275
00278       NVSG_API void * operator new( size_t size       // Size in bytes of demanded memory block.
00279                                   , const char * src  // Source file where allocation takes place.
00280                                   , unsigned int ln   // Line number within the source file where allocation takes place.
00281                                   );
00282 #endif
00283
00284
00290       NVSG_API void * operator new( size_t size // Size in bytes of demanded memory block.
00291                                   , void * p    // Start address of a valid memory block where the object will be created.
00292                                   );
00294
00295       NVSG_API void operator delete( void * p    // Start address of memory block to be freed.
00296                                   , size_t size // Size of memory block to be freed.
00297                                   );
00298   };
00299
00300
00301   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00302   // implementation following
00303   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00304
00310   inline void Chunk::init()
00311   {
00312     m_rawMem = ::new unsigned char[m_chunkSize];
00313
00314     m_firstAvailableBlock = 0;
00315     m_blocksAvailable = numBlocks;
00316
00317     unsigned char * p = m_rawMem;
00318     for ( unsigned char i=0; i!=numBlocks; p+=m_blockSize )
00319     {
00320       // code indices of next available blocks in first byte of each block
00321       *p = ++i;
00322     }
00323   }
00324
00330   inline void Chunk::freeMemory()
00331   {
00332     // should not attempt to free memory of a chunk in use
00333     NVSG_ASSERT(isUnused());
00334     ::delete[] m_rawMem;
00335   }
00336
00342   inline void * Chunk::alloc()
00343   {
00344     if ( !m_blocksAvailable )
00345     {
00346       // this needs to be handled in superior layers
00347       return NULL;
00348     }
00349
00350     unsigned char * p = &m_rawMem[m_firstAvailableBlock*m_blockSize];
00351     // index of next block available is coded in first byte
00352     m_firstAvailableBlock = *p;
00353     // one block less available in this chunk
00354     --m_blocksAvailable;
00355
00356     return (void *)p;
00357   }
00358
00364   inline void Chunk::dealloc(void * p)
00365   {
00366     unsigned char * ptr = (unsigned char*)p;
00367
00368     // range check
00369     NVSG_ASSERT(ptr>=m_rawMem);
00370     NVSG_ASSERT(ptr<&m_rawMem[m_chunkSize]);
00371     // alignment check
00372     NVSG_ASSERT(!((ptr-m_rawMem)%m_blockSize));
00373
00374     *ptr = m_firstAvailableBlock;
00375     m_firstAvailableBlock = (unsigned char)((ptr - m_rawMem) / m_blockSize);
00376
00377     // truncation check
00378     NVSG_ASSERT(m_firstAvailableBlock==((ptr-m_rawMem)/m_blockSize));
00379     ++m_blocksAvailable;
00380   }
00381
00387   inline bool Chunk::operator==(const Chunk& rhs) const
00388   {
00389     // consider chunks to be equal if they point to same raw memory location
00390     NVSG_ASSERT(    ( m_rawMem != rhs.m_rawMem )
00391                 ||  (     ( m_blockSize           == rhs.m_blockSize )
00392                       &&  ( m_firstAvailableBlock == rhs.m_firstAvailableBlock )
00393                       &&  ( m_blocksAvailable     == rhs.m_blocksAvailable ) ) );
00394     return (  m_rawMem==rhs.m_rawMem );
00395   }
00396
00402   inline bool Chunk::operator!=(const Chunk& rhs) const
00403   {
00404     return !operator==(rhs);
00405   }
00406
00412   inline unsigned char Chunk::blocksAvailable() const
00413   {
00414     return m_blocksAvailable;
00415   }
00416
00422   inline bool Chunk::isInsideBounds(void * p) const
00423   {
00424     return p>=lowerBound() && p<upperBound();
00425   }
00426
00432   inline bool Chunk::isUnused() const
00433   {
00434     return m_blocksAvailable==numBlocks;
00435   }
00436
00442   inline void * Chunk::lowerBound() const
00443   {
00444     return (void*)m_rawMem;
00445   }
00446
00452   inline void * Chunk::upperBound() const
00453   {
00454     return (void*)&m_rawMem[m_chunkSize];
00455   }
00456
00462   inline void FixedAllocator::init(size_t blockSize)
00463   {
00464     m_blockSize = blockSize;
00465   }
00466
00472   inline void * IAllocator::operator new(size_t size)
00473   {
00474     return theAllocator::instance()->alloc(size);
00475   }
00476
00477 #if defined(_DEBUG)
00478   // provide memory leak detection in debug mode
00479   inline void * IAllocator::operator new(size_t size, const char * src, unsigned int ln)
00480   {
00481     return theAllocator::instance()->alloc(size, src, ln);
00482   }
00483 #endif
00484
00490   inline void * IAllocator::operator new(size_t size, void * p)
00491   {
00492     // as this is used when constructing an object at a explicit
00493     // specified memory location, that location shoud be a valid
00494     // one - assert this!
00495     NVSG_ASSERT(p);
00496     return p;
00497   }
00498
00504   inline void IAllocator::operator delete(void * p, size_t size)
00505   {
00506     theAllocator::instance()->dealloc(p, size);
00507   }
00508
00509 } // namespace nvutil
00510
Generated on Fri Aug 4 08:32:59 2006 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 Fri Aug 4 08:33:14 2006 for NVSGSDK by NVIDIA


AnalyzeTraverser.h Source File

AnalyzeTraverser.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"
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       size_t        objectCount;
00041   };
00042
00043   class CombinableResult : public AnalyzeResult
00044   {
00045     public:
00046       virtual ~CombinableResult() {};
00047
00048     public:
00049       size_t  combinableCount;
00050       size_t  reducedCount;
00051   };
00052
00057   class DenormalizedNormalsResult : public AnalyzeResult
00058   {
00059     public:
00060       virtual ~DenormalizedNormalsResult() {}
00061
00062     public:
00063       size_t  denormalizedNormalsCount;
00064       size_t  denormalizedNormalsNumber;
00065   };
00066
00072   class EmptyResult : public AnalyzeResult
00073   {
00074     public:
00076       virtual ~EmptyResult() {}
00077
00078     public:
00079       size_t  emptyCount;
00080   };
00081
00087   class EquivalenceResult : public AnalyzeResult
00088   {
00089     public:
00091       virtual ~EquivalenceResult() {}
00092
00093     public:
00094       size_t  equivalentCount;
00095       size_t  reducedCount;
00096   };
00097
00103   class IdentityResult : public AnalyzeResult
00104   {
00105     public:
00107       virtual ~IdentityResult() {}
00108
00109     public:
00110       size_t  identityCount;
00111   };
00112
00118   class MissingResult : public AnalyzeResult
00119   {
00120     public:
00122       virtual ~MissingResult()  {}
00123
00124     public:
00125       size_t  missingCount;
00126   };
00127
00132   class NullNormalsResult : public AnalyzeResult
00133   {
00134     public:
00135       virtual ~NullNormalsResult() {}
00136
00137     public:
00138       size_t  nullNormalsCount;
00139       size_t  nullNormalsNumber;
00140   };
00141
00147   class SingleChildResult : public AnalyzeResult
00148   {
00149     public:
00151       virtual ~SingleChildResult()  {}
00152
00153     public:
00154       size_t  singleChildCount;
00155   };
00156
00162   class ShortStrippedResult : public AnalyzeResult
00163   {
00164     public:
00165       virtual ~ShortStrippedResult() {}
00166
00167     public:
00168       size_t shortStrippedCount;
00169       size_t shortStrippedNumber;
00170   };
00171
00209   class AnalyzeTraverser : public Traverser
00210   {
00211     public:
00213       NVSG_API AnalyzeTraverser( void );
00214
00223       NVSG_API size_t getAnalysis( std::vector<AnalyzeResult*> &results ) const;
00224
00225     protected:
00229       NVSG_API virtual ~AnalyzeTraverser( void );
00230
00236       NVSG_API virtual void doApply( const nvsg::Scene *scene );
00237
00243       NVSG_API virtual void handleAnimatedQuads( const nvsg::AnimatedQuads * p );
00244
00250       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p );
00251
00257       NVSG_API virtual void handleAnimatedTriangles( const nvsg::AnimatedTriangles * p );
00258
00264       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00265
00271       NVSG_API virtual void handleBlendAttribute( const nvsg::BlendAttribute * p );
00272
00277       NVSG_API virtual void handleCgFx( const nvsg::CgFx * p );
00278
00284       NVSG_API virtual void handleDepthAttribute( const nvsg::DepthAttribute * p );
00285
00291       NVSG_API virtual void handleDirectedLight( const nvsg::DirectedLight * p );
00292
00298       NVSG_API virtual void handleFaceAttribute( const nvsg::FaceAttribute * p );
00299
00306       NVSG_API virtual void handleFramedTrafoAnimation( const nvsg::FramedAnimation<nvmath::Trafo> * p );
00307
00314       NVSG_API virtual void handleFramedVNVectorAnimation( const nvsg::FramedAnimation<nvsg::VNVector> * p );
00315
00321       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p );
00322
00328       NVSG_API virtual void handleGroup( const nvsg::Group * p );
00329
00337       NVSG_API virtual void handleLinearInterpolatedTrafoAnimation( const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * p );
00338
00346       NVSG_API virtual void handleLinearInterpolatedVNVectorAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> * p );
00347
00353       NVSG_API virtual void handleLineAttribute( const nvsg::LineAttribute * p );
00354
00360       NVSG_API virtual void handleLines( const nvsg::Lines * p );
00361
00367       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips * p );
00368
00374       NVSG_API virtual void handleLOD( const nvsg::LOD * p );
00375
00381       NVSG_API virtual void handleMaterial( const nvsg::Material * p );
00382
00388       NVSG_API virtual void handlePointAttribute( const nvsg::PointAttribute * p );
00389
00395       NVSG_API virtual void handlePointLight( const nvsg::PointLight * p );
00396
00402       NVSG_API virtual void handlePoints( const nvsg::Points * p );
00403
00409       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes * p );
00410
00416       NVSG_API virtual void handleQuads( const nvsg::Quads * p );
00417
00423       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips * p );
00424
00430       NVSG_API virtual void handleShape( const nvsg::Shape * p );
00431
00437       NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles * p );
00438
00444       NVSG_API virtual void handleSpotLight( const nvsg::SpotLight * p );
00445
00451       NVSG_API virtual void handleStatePass( const nvsg::StatePass * p );
00452
00458       NVSG_API virtual void handleStateSet( const nvsg::StateSet * p );
00459
00465       NVSG_API virtual void handleStateVariant( const nvsg::StateVariant * p );
00466
00472       NVSG_API virtual void handleSwitch( const nvsg::Switch * p );
00473
00479       NVSG_API virtual void handleTextureAttribute( const nvsg::TextureAttribute * p );
00480
00487       NVSG_API virtual void handleTextureAttributeItem( const nvsg::TextureAttributeItem * p
00488                                                       , size_t tu );
00489
00495       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00496
00502       NVSG_API virtual void handleTriangles( const nvsg::Triangles * p );
00503
00509       NVSG_API virtual void handleTriFans( const nvsg::TriFans * p );
00510
00516       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips * p );
00517
00525       NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet * p );
00526
00527       void postTraverseGroup( const nvsg::Group * p );
00528       bool preTraverseGroup( const nvsg::Group * p );
00529
00530     private:
00531       template<typename T>
00532         void analyzeCombinable( const T *p
00533                               , std::map<const nvsg::StateSet*,std::vector<std::pair<const T*,size_t> > > &mvpT );
00534       void analyzeCombinable( const nvsg::GeoNode *p, std::vector<const nvsg::GeoNode *> &vgn );
00535       void analyzeEmpty( const nvsg::Object * p, size_t numberOfElements );
00536       void analyzeEquivalent( const nvsg::Object *p );
00537       void analyzeNormalsNormalized( const nvsg::VertexAttributeSet * p );
00538       void analyzeMissing( const nvsg::Object * p, const void * ptr );
00539       void analyzeShortStripped( const nvsg::StrippedPrimitiveSet * p, size_t minCount );
00540       void analyzeSingleChild( const nvsg::Group * p );
00541       template<typename T>
00542         void extractCombinableInfo( unsigned int oc
00543                                   , std::map<const nvsg::StateSet*,std::vector<std::pair<const T*,size_t> > > &mvpT );
00544       void extractCombinableInfo( std::vector<const nvsg::GeoNode *> &vgn );
00545       bool isToBeHandled( const nvsg::Object *p, size_t numberOfOwners );
00546
00547     private:
00548       class EquivalenceInfo
00549       {
00550         public :
00551           std::vector<const nvsg::Object *> uniqueObjects;
00552           std::set<const nvsg::Object *>    equivalentObjects;
00553       };
00554
00555       std::map<unsigned int,size_t>                     m_countMap;
00556       std::stack<std::vector<const nvsg::GeoNode*> >    m_combinableGeoNodes;
00557       std::map<unsigned int,std::pair<size_t,size_t> >  m_combinableInfo;
00558       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Lines*,size_t> > >       m_combinableLines;
00559       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::LineStrips*,size_t> > >  m_combinableLineStrips;
00560       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Points*,size_t> > >      m_combinablePoints;
00561       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::QuadMeshes*,size_t> > >  m_combinableQuadMeshes;
00562       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Quads*,size_t> > >       m_combinableQuads;
00563       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::QuadStrips*,size_t> > >  m_combinableQuadStrips;
00564       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::Triangles*,size_t> > >   m_combinableTriangles;
00565       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::TriFans*,size_t> > >     m_combinableTriFans;
00566       std::map<const nvsg::StateSet*,std::vector<std::pair<const nvsg::TriStrips*,size_t> > >   m_combinableTriStrips;
00567       const nvsg::StateSet *                            m_currentStateSet;
00568       std::pair<size_t,size_t>                          m_denormalizedNormals;
00569       std::map<unsigned int, size_t>                    m_emptyMap;
00570       std::map<unsigned int, EquivalenceInfo>           m_equivalenceMap;
00571       size_t                                            m_identityCount;
00572       std::map<unsigned int, size_t>                    m_missingMap;
00573       std::set<const nvsg::Object *>                    m_multiOwnerObjects;
00574       std::pair<size_t,size_t>                          m_nullNormals;
00575       std::map<unsigned int, size_t>                    m_singleChildMap;
00576       std::map<unsigned int, std::pair<size_t,size_t> > m_shortStripped;
00577   };
00578 }
Generated on Fri Aug 4 08:32:59 2006 for NVSGSDK by NVIDIA


AnimatedQuads.h File Reference

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

Include dependency graph for AnimatedQuads.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 Fri Aug 4 08:33:16 2006 for NVSGSDK by NVIDIA


AnimatedQuads.h Source File

AnimatedQuads.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/Animation.h"
00018 #include "nvsg/Quads.h"
00019 #include "nvsg/VNVector.h"
00020
00021 namespace nvsg
00022 {
00028   class AnimatedQuads : public Quads
00029   {
00030     public:
00037       NVSG_API static const AnimatedQuads * create( const Animation<VNVector> *animation = NULL );
00038
00048       NVSG_API static const AnimatedQuads * createFromBase( const Quads &rhs
00049                                                           , const Animation<VNVector> *animation = NULL );
00050
00054       NVSG_API virtual const AnimatedQuads * clone( void ) const;
00055
00059       NVSG_API const Animation<VNVector> * getAnimation( void ) const;
00060
00069       NVSG_API void setAnimation( const Animation<VNVector> *animation );
00070
00078       NVSG_API void setAnimationFrame( size_t frame );
00079
00082       NVSG_API virtual size_t getNumberOfFrames( void ) const;
00083
00091       NVSG_API AnimatedQuads & operator=( const AnimatedQuads & rhs );
00092
00104       NVSG_API virtual bool isEquivalent( const Object *p
00105                                         , bool ignoreNames
00106                                         , bool deepCompare ) const;
00107
00108     protected:
00114       NVSG_API AnimatedQuads( const Animation<VNVector> *animation );
00115
00122       NVSG_API AnimatedQuads( const Quads &rhs, const Animation<VNVector> *animation );
00123
00129       NVSG_API AnimatedQuads( const AnimatedQuads &rhs );
00130
00136       NVSG_API virtual ~AnimatedQuads( void );
00137
00143       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00144
00145     private:
00146       AnimatedQuads();    //  private default constructor to prevent use
00147
00148     private:
00149       const Animation<VNVector> * m_animation;
00150       size_t                      m_currentFrame;
00151   };
00152
00153   // - - - - - - - - - - - - - - - - - - - - - - - - -
00154   // inlines
00155   // - - - - - - - - - - - - - - - - - - - - - - - - -
00156
00157   inline const Animation<VNVector> * AnimatedQuads::getAnimation( void ) const
00158   {
00159     NVSG_TRACE();
00160     return( m_animation );
00161   }
00162
00163 } //  namespace nvsg
Generated on Fri Aug 4 08:32:59 2006 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 Fri Aug 4 08:33:16 2006 for NVSGSDK by NVIDIA


AnimatedTransform.h Source File

AnimatedTransform.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/Animation.h"
00018 #include  "nvsg/Transform.h"
00019
00020 namespace nvsg
00021 {
00027   class AnimatedTransform : public Transform
00028   {
00029     public:
00036       NVSG_API static const AnimatedTransform * create( const Animation<nvmath::Trafo> *animation = NULL );
00037
00047       NVSG_API static const AnimatedTransform * createFromBase( const Transform &rhs
00048                                                               , const Animation<nvmath::Trafo> *animation = NULL );
00049
00053       NVSG_API virtual AnimatedTransform * clone( void ) const;
00054
00058       NVSG_API const Animation<nvmath::Trafo> * getAnimation( void ) const;
00059
00069       NVSG_API void setAnimation( const Animation<nvmath::Trafo> *animation );
00070
00077       NVSG_API void setAnimationFrame( size_t frame );
00078
00084       NVSG_API virtual void setTrafo( const nvmath::Trafo &trafo );
00085
00088       NVSG_API virtual size_t getNumberOfFrames( void ) const;
00089
00097       NVSG_API AnimatedTransform & operator=( const AnimatedTransform & rhs );
00098
00114       NVSG_API virtual bool isEquivalent( const Object *p
00115                                         , bool ignoreNames
00116                                         , bool deepCompare ) const;
00117
00118     protected:
00124       NVSG_API AnimatedTransform( const Animation<nvmath::Trafo> *animation );
00125
00133       NVSG_API AnimatedTransform( const Transform &rhs, const Animation<nvmath::Trafo> *animation );
00134
00140       NVSG_API AnimatedTransform( const AnimatedTransform& rhs );
00141
00147       NVSG_API virtual ~AnimatedTransform( void );
00148
00154       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00155
00156     private:
00157       AnimatedTransform();    //  private default constructor to prevent use
00158
00159     private:
00160       const Animation<nvmath::Trafo>  * m_animation;
00161       size_t                            m_currentFrame;
00162   };
00163
00164   // - - - - - - - - - - - - - - - - - - - - - - - - -
00165   // inlines
00166   // - - - - - - - - - - - - - - - - - - - - - - - - -
00167
00168   inline const Animation<nvmath::Trafo> * AnimatedTransform::getAnimation( void ) const
00169   {
00170     NVSG_TRACE();
00171     return( m_animation );
00172   }
00173
00174 } //  namespace nvsg
Generated on Fri Aug 4 08:32:59 2006 for NVSGSDK by NVIDIA


AnimatedTriangles.h File Reference

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

Include dependency graph for AnimatedTriangles.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Fri Aug 4 08:33:18 2006 for NVSGSDK by NVIDIA


AnimatedTriangles.h Source File

AnimatedTriangles.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/Animation.h"
00018 #include "nvsg/Triangles.h"
00019 #include "nvsg/VNVector.h"
00020
00021 namespace nvsg
00022 {
00028   class AnimatedTriangles : public Triangles
00029   {
00030     public:
00037       NVSG_API static const AnimatedTriangles * create( const Animation<VNVector> *animation = NULL );
00038
00048       NVSG_API static const AnimatedTriangles * createFromBase( const Triangles &rhs
00049                                                               , const Animation<VNVector> *animation = NULL );
00050
00054       NVSG_API virtual const AnimatedTriangles * clone( void ) const;
00055
00059       NVSG_API const Animation<VNVector> * getAnimation( void ) const;
00060
00069       NVSG_API void setAnimation( const Animation<VNVector> *animation );
00070
00078       NVSG_API void setAnimationFrame( size_t frame );
00079
00082       NVSG_API virtual size_t getNumberOfFrames( void ) const;
00083
00091       NVSG_API AnimatedTriangles & operator=( const AnimatedTriangles & rhs );
00092
00107       NVSG_API virtual bool isEquivalent( const Object *p
00108                                         , bool ignoreNames
00109                                         , bool deepCompare ) const;
00110
00111     protected:
00117       NVSG_API AnimatedTriangles( const Animation<VNVector> *animation );
00118
00126       NVSG_API AnimatedTriangles( const Triangles &rhs, const Animation<VNVector> *animation );
00127
00133       NVSG_API AnimatedTriangles( const AnimatedTriangles &rhs );
00134
00140       NVSG_API virtual ~AnimatedTriangles(void);
00141
00147       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00148
00149     private:
00150       AnimatedTriangles();    //  private default constructor to prevent use
00151
00152     private:
00153       const Animation<VNVector> * m_animation;
00154       size_t                      m_currentFrame;
00155   };
00156
00157   // - - - - - - - - - - - - - - - - - - - - - - - - -
00158   // inlines
00159   // - - - - - - - - - - - - - - - - - - - - - - - - -
00160
00161   inline const Animation<VNVector> * AnimatedTriangles::getAnimation( void ) const
00162   {
00163     NVSG_TRACE();
00164     return( m_animation );
00165   }
00166
00167 } //  namespace nvsg
Generated on Fri Aug 4 08:32:59 2006 for NVSGSDK by NVIDIA


Animation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.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 Fri Aug 4 08:33:19 2006 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
00017 #include  "nvsg/Object.h"
00018
00019 namespace nvsg
00020 {
00026   template<typename T> class Animation : public Object
00027   {
00028     public:
00032       virtual const Animation<T> * clone( void ) const = 0;
00033
00036       virtual size_t getNumberOfFrames( void ) const = 0;
00037
00045       virtual const T & operator[]( size_t i ) const = 0;
00046
00047     protected:
00052       Animation( void );
00053
00058       virtual ~Animation( void );
00059
00065       Animation<T> & operator=( const Animation<T> & rhs );
00066   };
00067
00068   template<typename T>
00069   Animation<T>::Animation( void )
00070   {
00071     NVSG_TRACE();
00072   }
00073
00074   template<typename T>
00075   Animation<T>::~Animation( void )
00076   {
00077     NVSG_TRACE();
00078   }
00079
00080   template<typename T>
00081   Animation<T> & Animation<T>::operator=(const Animation<T> & rhs)
00082   {
00083     NVSG_TRACE();
00084     if (&rhs != this)
00085     {
00086       Object::operator=(rhs);
00087     }
00088     return *this;
00089   }
00090
00091 } //  namespace nvsg
Generated on Fri Aug 4 08:32:59 2006 for NVSGSDK by NVIDIA


AnimationManipulator.h File Reference

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

Include dependency graph for AnimationManipulator.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvmath
namespace | nvsg
namespace | nvui

Detailed Description

Generated on Fri Aug 4 08:33:19 2006 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
00019 //  forward declarations
00020 namespace nvmath
00021 {
00022   class Trafo;
00023 }
00024 namespace nvsg
00025 {
00026   template<typename T> class Animation;
00027
00028   class ViewState;
00029 }
00030
00031 namespace nvui
00032 {
00046   class AnimationManipulator : public Manipulator
00047   {
00048     public:
00051       NVSG_API AnimationManipulator();
00052
00056       NVSG_API virtual ~AnimationManipulator();
00057
00082       NVSG_API virtual bool updateFrame();
00083
00089       NVSG_API virtual bool isActive() { return false; };
00090
00108       NVSG_API void setNumberOfFrames( size_t frames );
00109
00121       NVSG_API void setCameraAnimation( const nvsg::Animation<nvmath::Trafo> * animation );
00122
00129       NVSG_API void nextFrame();
00130
00137       NVSG_API void previousFrame();
00138
00142       NVSG_API void firstFrame();
00143
00147       NVSG_API void lastFrame();
00148
00156       NVSG_API void gotoFrame(size_t frame);
00157
00158     protected:
00159       // we have different kinds of animations: camera animation,
00160       // skin / bone animation transformation animation ...
00161       const nvsg::Animation<nvmath::Trafo>  * m_cameraAnimation;
00162
00163       size_t m_currentFrame;
00164       size_t m_numberOfFrames;
00165   };
00166
00167   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00168   // inlines
00169   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00170   inline void AnimationManipulator::gotoFrame( size_t frame )
00171   {
00172     NVSG_TRACE();
00173
00174     NVSG_ASSERT(frame < m_numberOfFrames);
00175     m_currentFrame = frame;
00176   }
00177
00178   inline void AnimationManipulator::nextFrame()
00179   {
00180     NVSG_TRACE();
00181     if (m_currentFrame == 0xFFFFFFFF)
00182     {
00183       firstFrame();
00184     }
00185     else
00186     {
00187       m_currentFrame = ((++m_currentFrame) % m_numberOfFrames) ? m_currentFrame : 0;
00188     }
00189   }
00190
00191   inline void AnimationManipulator::previousFrame()
00192   {
00193     NVSG_TRACE();
00194     if (m_currentFrame == 0xFFFFFFFF)
00195     {
00196       lastFrame();
00197     }
00198     else
00199     {
00200       m_currentFrame = ((--m_currentFrame) < 0 ) ? m_numberOfFrames : m_currentFrame;
00201     }
00202   }
00203
00204   inline void AnimationManipulator::firstFrame()
00205   {
00206     NVSG_TRACE();
00207     (m_numberOfFrames > 0) ? m_currentFrame = 0 : m_currentFrame = 0xFFFFFFFF;
00208   }
00209
00210   inline void AnimationManipulator::lastFrame()
00211   {
00212     NVSG_TRACE();
00213     (m_numberOfFrames > 0) ? m_currentFrame = m_numberOfFrames-1 : m_currentFrame = 0xFFFFFFFF;
00214   }
00215
00216   inline void AnimationManipulator::setNumberOfFrames(size_t frames)
00217   {
00218     NVSG_TRACE();
00219     if (frames == 0)
00220     {
00221       m_currentFrame = 0xFFFFFFFF;
00222     }
00223     m_numberOfFrames = frames;
00224   }
00225
00226 } // namespace nvui
Generated on Fri Aug 4 08:32:59 2006 for NVSGSDK by NVIDIA


AppTraverser.h File Reference

#include "nvsgcommon.h"
#include "ModelViewTraverser.h"
#include "nvsg/ViewState.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 Fri Aug 4 08:33:21 2006 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
00017 #include "ModelViewTraverser.h"
00018 #include  "nvsg/ViewState.h"
00019
00020 namespace nvtraverser {
00021
00023
00030 class AppTraverser : public ModelViewTraverser
00031 {
00032 public:
00034   NVSG_API AppTraverser();
00035
00036 protected:
00038   NVSG_API virtual ~AppTraverser();
00039
00041
00044   NVSG_API virtual bool needsTraversal( void ) const;
00045
00047   NVSG_API virtual void doApply( const nvsg::Scene *scene );
00048
00049   // handler routine overrides
00050   NVSG_API virtual void handleGeoNode( const nvsg::GeoNode *p );
00051   NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p );
00052   NVSG_API virtual void handleAnimatedQuads( const nvsg::AnimatedQuads *p );
00053   NVSG_API virtual void handleAnimatedTriangles( const nvsg::AnimatedTriangles *p );
00054   NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles *p );
00055   NVSG_API virtual void handleCgFx( const nvsg::CgFx *p );
00056   NVSG_API virtual void handleHighlightBox( const nvsg::HighlightBox *p, const nvsg::PrimitiveSet * primitive );
00057
00058   // traverseLight override
00059   NVSG_API virtual void traverseLight( const nvsg::LightSource *p );
00060
00061   // data accessible for derived classes
00062   bool   m_bApplyingCgFx;
00063   size_t m_animationFrame;
00064
00065 private:
00066   // Some data to cache so we can decide if we really have to apply the animation data.
00067   // This does not help to prevent from unneeded traversal steps since we can't
00068   // decide for derived classes.
00069   const nvsg::ViewState * m_pLastViewState;
00070   const nvsg::Scene     * m_pLastScene;
00071   size_t                  m_lastAnimationFrame;
00072   bool                    m_bApplyAnimationKey;
00073 };
00074
00075 } // namespace nvtraverser
Generated on Fri Aug 4 08:32:59 2006 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 Fri Aug 4 08:33:22 2006 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 {
00026   class Billboard : public Group
00027   {
00028     public:
00033       NVSG_API static const Billboard * create();
00034
00042       NVSG_API static const Billboard * createFromBase( const Group &rhs );
00043
00047       NVSG_API virtual const Billboard * clone() const;
00048
00058       NVSG_API nvmath::Trafo getTrafoAxisAligned( const nvmath::Vec3f & viewerPosition ) const;
00059
00074       NVSG_API nvmath::Trafo getTrafoScreenAligned( const nvmath::Vec3f & viewerPosition
00075                                                   , const nvmath::Vec3f & upVector ) const;
00076
00083       NVSG_API bool isScreenAligned() const;
00084
00091       NVSG_API void setScreenAligned( bool on );
00092
00100       NVSG_API const nvmath::Vec3f & getRotationAxis() const;
00101
00109       NVSG_API void setRotationAxis( const nvmath::Vec3f &axis );
00110
00117       NVSG_API Billboard & operator=( const Billboard & rhs );
00118
00129       NVSG_API virtual bool isEquivalent( const Object *p
00130                                         , bool ignoreNames
00131                                         , bool deepCompare ) const;
00132
00133     protected:
00136       NVSG_API Billboard();
00137
00143       NVSG_API explicit Billboard( const Group &rhs );
00144
00148       NVSG_API Billboard( const Billboard &rhs );
00149
00153       NVSG_API virtual ~Billboard();
00154
00155     private:
00156       nvmath::Vec3f m_rotationAxis;
00157       bool          m_screenAligned;
00158   };
00159
00160   inline const nvmath::Vec3f & Billboard::getRotationAxis() const
00161   {
00162     return( m_rotationAxis );
00163   }
00164
00165   inline bool Billboard::isScreenAligned() const
00166   {
00167     return( m_screenAligned );
00168   }
00169
00170   inline void Billboard::setRotationAxis( const nvmath::Vec3f &rotationAxis )
00171   {
00172     m_rotationAxis = rotationAxis;
00173     invalidateBoundingSphere();
00174   }
00175
00176   inline void Billboard::setScreenAligned( bool on )
00177   {
00178     m_screenAligned = on;
00179     invalidateBoundingSphere();
00180   }
00181 }
Generated on Fri Aug 4 08:32:59 2006 for NVSGSDK by NVIDIA


Bitmap.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vec4f.h"
#include "nvsg/Map.h"

Include dependency graph for Bitmap.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Fri Aug 4 08:33:23 2006 for NVSGSDK by NVIDIA


Bitmap.h Source File

Bitmap.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/Vec4f.h"
00017 #include "nvsg/Map.h"
00018
00019 namespace nvsg
00020 {
00026   class Bitmap : public Map
00027   {
00028     public:
00034       NVSG_API static const Bitmap * create( size_t width, size_t height, unsigned char * data );
00035
00039       NVSG_API virtual const Bitmap * clone( void ) const;
00040
00044       NVSG_API const nvmath::Vec4f & getColor( void ) const;
00045
00050       NVSG_API void setColor( const nvmath::Vec4f &color );
00051
00052     protected:
00055       NVSG_API Bitmap( size_t width, size_t height, unsigned char * data );
00056
00060       NVSG_API Bitmap( const Bitmap &rhs );
00061
00065       NVSG_API virtual ~Bitmap(void);
00066
00067     private:
00068       Bitmap( void );   // private default constructor to prevent creation
00069
00070     private:
00071       nvmath::Vec4f m_color;
00072   };
00073
00074   inline const nvmath::Vec4f & Bitmap::getColor( void ) const
00075   {
00076     NVSG_TRACE();
00077     return( m_color );
00078   }
00079
00080   inline void Bitmap::setColor( const nvmath::Vec4f &color )
00081   {
00082     NVSG_TRACE();
00083     m_color = color;
00084   }
00085 }
Generated on Fri Aug 4 08:32:59 2006 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 Fri Aug 4 08:33:24 2006 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
00021 template <int n>
00022 class Bit
00023 {
00024 public:
00025   enum { mask = 1<<n };
00026 };
00027
00028 //  Don't need to document these tiny little helper defines !!!
00029 #if ! defined( DOXYGEN_IGNORE )
00030
00031 #define BIT(n) nvutil::Bit<n>::mask
00032
00033 #define BIT0  BIT(0)
00034 #define BIT1  BIT(1)
00035 #define BIT2  BIT(2)
00036 #define BIT3  BIT(3)
00037 #define BIT4  BIT(4)
00038 #define BIT5  BIT(5)
00039 #define BIT6  BIT(6)
00040 #define BIT7  BIT(7)
00041 #define BIT8  BIT(8)
00042 #define BIT9  BIT(9)
00043 #define BIT10 BIT(10)
00044 #define BIT11 BIT(11)
00045 #define BIT12 BIT(12)
00046 #define BIT13 BIT(13)
00047 #define BIT14 BIT(14)
00048 #define BIT15 BIT(15)
00049 #define BIT16 BIT(16)
00050 #define BIT17 BIT(17)
00051 #define BIT18 BIT(18)
00052 #define BIT19 BIT(19)
00053 #define BIT20 BIT(20)
00054 #define BIT21 BIT(21)
00055 #define BIT22 BIT(22)
00056 #define BIT23 BIT(23)
00057 #define BIT24 BIT(24)
00058 #define BIT25 BIT(25)
00059 #define BIT26 BIT(26)
00060 #define BIT27 BIT(27)
00061 #define BIT28 BIT(28)
00062 #define BIT29 BIT(29)
00063 #define BIT30 BIT(30)
00064 #define BIT31 BIT(31)
00065
00066 #endif  //  DOXYGEN_IGNORE
00067
00068 } // namespace nvutil
00069
Generated on Fri Aug 4 08:33:00 2006 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 Fri Aug 4 08:33:24 2006 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:
00057       NVSG_API static const BlendAttribute * create();
00058
00066       NVSG_API static const BlendAttribute * createFromBase( const StateAttribute &rhs );
00067
00071       NVSG_API virtual const BlendAttribute * clone() const;
00072
00081       NVSG_API void setBlendFunctions( BlendFunction sourceFunction
00082                                      , BlendFunction destinationFunction
00083                                      );
00084
00088       NVSG_API BlendFunction getSourceFunction() const;
00089
00093       NVSG_API BlendFunction getDestinationFunction() const;
00094
00102       NVSG_API virtual bool isTransparent() const;
00103
00113       NVSG_API virtual bool isEquivalent( const Object *p
00114                                         , bool ignoreNames
00115                                         , bool deepCompare ) const;
00116
00123       NVSG_API BlendAttribute & operator=(const BlendAttribute & rhs);
00124
00125     protected:
00129       NVSG_API BlendAttribute();
00130
00137       NVSG_API explicit BlendAttribute( const StateAttribute &rhs );
00138
00143       NVSG_API BlendAttribute( const BlendAttribute &rhs );
00144
00148       NVSG_API virtual ~BlendAttribute();
00149
00150     private:
00151       BlendFunction  m_sourceFunction;
00152       BlendFunction  m_destinationFunction;
00153   };
00154
00155   inline BlendFunction BlendAttribute::getSourceFunction() const
00156   {
00157     return( m_sourceFunction );
00158   }
00159
00160   inline BlendFunction BlendAttribute::getDestinationFunction() const
00161   {
00162     return( m_destinationFunction );
00163   }
00164
00165 } // namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


Camera.h File Reference

#include "nvsgcommon.h"
#include "nvsg/CullData.h"
#include "nvmath/Vec2f.h"
#include "nvmath/Vec3f.h"
#include "nvmath/Mat44f.h"
#include "nvmath/Quatf.h"
#include "nvsg/Object.h"
#include "nvsg/LightSource.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 | nvmath
namespace | nvsg

Detailed Description

Generated on Fri Aug 4 08:33:25 2006 for NVSGSDK by NVIDIA


Camera.h Source File

Camera.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 "nvmath/Vec2f.h"
00018 #include "nvmath/Vec3f.h"
00019 #include "nvmath/Mat44f.h"
00020 #include "nvmath/Quatf.h"
00021 #include "nvsg/Object.h"
00022 #include "nvsg/LightSource.h"
00023
00024 //  forward declarations
00025 namespace nvmath
00026 {
00027   class Mat44f;
00028   class Vec2f;
00029 }
00030 namespace nvsg
00031 {
00032   class LightSource;
00033   class Node;
00034 }
00035
00036 namespace nvsg
00037 {
00054   class Camera : public Object
00055   {
00056     public:
00061       NVSG_API virtual const Camera * clone( void ) const = 0;
00062
00068       NVSG_API const nvmath::Vec3f & getPosition( void ) const;
00069
00076       NVSG_API void setPosition( const nvmath::Vec3f & pos );
00077
00084       NVSG_API const nvmath::Quatf & getOrientation( void ) const;
00085
00094       NVSG_API void setOrientation( const nvmath::Quatf & quat );
00095
00103       NVSG_API void setOrientation( const nvmath::Vec3f & dir
00104                                   , const nvmath::Vec3f & up );
00105
00111       NVSG_API nvmath::Vec3f getDirection( void ) const;
00112
00120       NVSG_API void setDirection( const nvmath::Vec3f & dir );
00121
00127       NVSG_API nvmath::Vec3f getUpVector( void ) const;
00128
00136       NVSG_API void setUpVector( const nvmath::Vec3f & up );
00137
00143       NVSG_API nvmath::Mat44f getWorldToViewMatrix( void ) const;
00144
00150       NVSG_API nvmath::Mat44f getViewToWorldMatrix( void ) const;
00151
00160       NVSG_API float getNearDistance( void ) const;
00161
00170       NVSG_API void setNearDistance( float nd );
00171
00178       NVSG_API float getFocusDistance( void ) const;
00179
00187       NVSG_API virtual void setFocusDistance( float fd );
00188
00197       NVSG_API float getFarDistance( void ) const;
00198
00207       NVSG_API void setFarDistance( float fd );
00208
00223       NVSG_API void calcNearFarDistances( const nvmath::Sphere3f &sphere );
00224
00232       NVSG_API bool isAutoClipPlanes( void ) const;
00233
00241       NVSG_API void setAutoClipPlanes( bool on );
00242
00246       NVSG_API virtual nvmath::Mat44f getProjection( void ) const = 0;
00247
00251       NVSG_API virtual nvmath::Mat44f getInverseProjection( void ) const = 0;
00252
00261       NVSG_API const nvmath::Vec2f & getWindowSize( void ) const;
00262
00271       NVSG_API void setWindowSize( const nvmath::Vec2f & size );
00272
00277       NVSG_API float getAspectRatio( void ) const;
00278
00288       NVSG_API void setAspectRatio( float ar
00289                                   , bool keepWidth = false );
00290
00304       NVSG_API const nvmath::Vec2f & getWindowOffset( void ) const;
00305
00319       NVSG_API void setWindowOffset( const nvmath::Vec2f &offset );
00320
00334       NVSG_API void getWindowRegion( nvmath::Vec2f & lowerLeft
00335                                    , nvmath::Vec2f & upperRight ) const;
00336
00350       NVSG_API void setWindowRegion( const nvmath::Vec2f & lowerLeft
00351                                    , const nvmath::Vec2f & upperRight );
00352
00358       NVSG_API size_t getNumberOfHeadLights( void ) const;
00359
00368       NVSG_API const LightSource * getHeadLight( size_t index ) const;
00369
00378       NVSG_API void addHeadLight( const LightSource * light );
00379
00389       NVSG_API void removeHeadLight( size_t index );
00390
00398       NVSG_API void clearHeadLights( void );
00399
00412       NVSG_API virtual void getPickRay( int x
00413                                       , int y
00414                                       , int w
00415                                       , int h
00416                                       , nvmath::Vec3f & rayOrigin
00417                                       , nvmath::Vec3f & rayDir ) const = 0;
00418
00428       NVSG_API void move( const nvmath::Vec3f & delta
00429                         , bool cameraRelative = true );
00430
00446       NVSG_API void orbit( const nvmath::Vec3f & axis
00447                          , float targetDistance
00448                          , float angle
00449                          , bool  cameraRelative = true );
00450
00461       NVSG_API void rotate( const nvmath::Vec3f& axis
00462                           , float angle
00463                           , bool  cameraRelative = true );
00464
00475       NVSG_API void zoom( float factor );
00476
00486       NVSG_API void zoom( const nvmath::Sphere3f & sphere
00487                         , float fovy = -1.0f );
00488
00494       void moveX( float val );
00495
00501       void moveY( float val );
00502
00508       void moveZ( float val );
00509
00516       void orbitX( float targetDistance
00517                  , float angle );
00518
00525       void orbitY( float targetDistance
00526                  , float angle );
00527
00535       void orbitZ( float targetDistance
00536                  , float angle );
00537
00543       void rotateX( float angle );
00544
00550       void rotateY( float angle );
00551
00557       void rotateZ( float angle );
00558
00563       NVSG_API virtual CullCode determineCullCode( const nvmath::Sphere3f &sphere ) const = 0;
00564
00565     protected:
00570       NVSG_API Camera( void );
00571
00577       NVSG_API Camera( const Camera& rhs );
00578
00583       NVSG_API virtual ~Camera( void );
00584
00591       NVSG_API Camera & operator=( const Camera & rhs );
00592
00598       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00599
00600     private:
00601       void _deepCopyHeadLights(std::vector<const LightSource *> headLights);
00602
00603     private:
00604       std::vector<const LightSource *>  m_headLights;
00605
00606       nvmath::Quatf m_orientation;
00607       nvmath::Vec3f m_position;
00608
00609       bool          m_isAutoClipPlanes;
00610       float         m_nearDist;
00611       float         m_focusDist;
00612       float         m_farDist;
00613
00614       nvmath::Vec2f m_windowSize;
00615       nvmath::Vec2f m_windowOffset;
00616       nvmath::Vec2f m_lowerLeft;
00617       nvmath::Vec2f m_upperRight;
00618
00619       mutable nvmath::Mat44f  m_viewToWorld;
00620       mutable bool            m_viewToWorldValid;
00621       mutable nvmath::Mat44f  m_worldToView;
00622       mutable bool            m_worldToViewValid;
00623   };
00624
00625   inline float Camera::getAspectRatio( void ) const
00626   {
00627     NVSG_TRACE();
00628     return( m_windowSize[0] / m_windowSize[1] );
00629   }
00630
00631   inline nvmath::Vec3f Camera::getDirection( void ) const
00632   {
00633     NVSG_TRACE();
00634     //  NOTE: normalizing shouldn't be necessary, but rounding errors do catch us!
00635     return( normalize( m_orientation * nvmath::Vec3f( 0.0f, 0.0f, -1.0f ) ) );
00636   }
00637
00638   inline float Camera::getFarDistance( void ) const
00639   {
00640     NVSG_TRACE();
00641     NVSG_ASSERT( m_nearDist < m_farDist );
00642     return( m_farDist );
00643   }
00644
00645   inline float Camera::getFocusDistance( void ) const
00646   {
00647     NVSG_TRACE();
00648     return( m_focusDist );
00649   }
00650
00651   inline const LightSource * Camera::getHeadLight( size_t index ) const
00652   {
00653     NVSG_TRACE();
00654     NVSG_ASSERT( index < m_headLights.size() );
00655     return m_headLights[index];
00656   }
00657
00658   inline float Camera::getNearDistance( void ) const
00659   {
00660     NVSG_TRACE();
00661     NVSG_ASSERT( m_nearDist < m_farDist );
00662     return( m_nearDist );
00663   }
00664
00665   inline size_t Camera::getNumberOfHeadLights( void ) const
00666   {
00667     NVSG_TRACE();
00668     return( m_headLights.size() );
00669   }
00670
00671   inline const nvmath::Quatf & Camera::getOrientation( void ) const
00672   {
00673     NVSG_TRACE();
00674     return( m_orientation );
00675   }
00676
00677   inline const nvmath::Vec3f & Camera::getPosition( void ) const
00678   {
00679     NVSG_TRACE();
00680     return( m_position );
00681   }
00682
00683   inline nvmath::Vec3f Camera::getUpVector( void ) const
00684   {
00685     NVSG_TRACE();
00686     //  NOTE: normalizing shouldn't be necessary, but rounding errors do catch us!
00687     return( normalize( m_orientation * nvmath::Vec3f( 0.0f, 1.0f, 0.0f ) ) );
00688   }
00689
00690   inline const nvmath::Vec2f & Camera::getWindowOffset( void ) const
00691   {
00692     NVSG_TRACE();
00693     return m_windowOffset;
00694   }
00695
00696   inline void Camera::getWindowRegion( nvmath::Vec2f & lowerLeft, nvmath::Vec2f & upperRight ) const
00697   {
00698     NVSG_TRACE();
00699     lowerLeft = m_lowerLeft;
00700     upperRight = m_upperRight;
00701   }
00702
00703   inline const nvmath::Vec2f & Camera::getWindowSize( void ) const
00704   {
00705     NVSG_TRACE();
00706     return( m_windowSize );
00707   }
00708
00709   inline bool Camera::isAutoClipPlanes( void ) const
00710   {
00711     NVSG_TRACE();
00712     return( m_isAutoClipPlanes );
00713   }
00714
00715   inline void Camera::setFarDistance( float fd )
00716   {
00717     NVSG_TRACE();
00718     NVSG_ASSERT( ( FLT_EPSILON < fd ) );
00719     m_farDist = fd;
00720     increaseIncarnation();
00721   }
00722
00723   inline void Camera::setNearDistance( float nd )
00724   {
00725     NVSG_TRACE();
00726     NVSG_ASSERT( ( FLT_EPSILON < nd ) );
00727     m_nearDist = nd;
00728     increaseIncarnation();
00729   }
00730
00731   inline void Camera::setWindowSize( const nvmath::Vec2f & size )
00732   {
00733     NVSG_TRACE();
00734     m_windowSize = size;
00735     increaseIncarnation();
00736   }
00737
00738   inline void Camera::setWindowOffset( const nvmath::Vec2f & offset )
00739   {
00740     NVSG_TRACE();
00741     m_windowOffset = offset;
00742     increaseIncarnation();
00743   }
00744
00745   inline void Camera::setWindowRegion( const nvmath::Vec2f & lowerLeft, const nvmath::Vec2f & upperRight )
00746   {
00747     NVSG_TRACE();
00748     m_lowerLeft  = lowerLeft;
00749     m_upperRight = upperRight;
00750     increaseIncarnation();
00751   }
00752
00753   inline void Camera::zoom( float factor )
00754   {
00755     NVSG_TRACE();
00756     NVSG_ASSERT( FLT_EPSILON < factor );
00757     m_windowSize *= factor;
00758     increaseIncarnation();
00759   }
00760
00761   inline void Camera::moveX( float val )
00762   {
00763     NVSG_TRACE();
00764     move( nvmath::Vec3f( val, 0.f, 0.f ) );
00765   }
00766
00767   inline void Camera::moveY( float val )
00768   {
00769     NVSG_TRACE();
00770     move( nvmath::Vec3f( val, 1.f, 0.f ) );
00771   }
00772
00773   inline void  Camera::moveZ( float val )
00774   {
00775     NVSG_TRACE();
00776     move( nvmath::Vec3f( val, 0.f, 1.f ) );
00777   }
00778
00779   inline void  Camera::orbitX( float targetDistance, float rad )
00780   {
00781     NVSG_TRACE();
00782     orbit( nvmath::Vec3f( 1.f, 0.f, 0.f ), targetDistance, rad );
00783   }
00784
00785   inline void  Camera::orbitY( float targetDistance, float rad )
00786   {
00787     NVSG_TRACE();
00788     orbit( nvmath::Vec3f( 0.f, 1.f, 0.f ), targetDistance, rad );
00789   }
00790
00791   inline void  Camera::orbitZ( float targetDistance, float rad )
00792   {
00793     NVSG_TRACE();
00794     orbit( nvmath::Vec3f( 0.f, 0.f, 1.f ), targetDistance, rad );
00795   }
00796
00797   inline void  Camera::rotateX( float rad )
00798   {
00799     NVSG_TRACE();
00800     rotate( nvmath::Vec3f(1.f, 0.f, 0.f), rad );
00801   }
00802
00803   inline void  Camera::rotateY( float rad )
00804   {
00805     NVSG_TRACE();
00806     rotate( nvmath::Vec3f(0.f, 1.f, 0.f), rad );
00807   }
00808
00809   inline void  Camera::rotateZ( float rad )
00810   {
00811     NVSG_TRACE();
00812     rotate( nvmath::Vec3f(0.f, 0.f, 1.f), rad );
00813   }
00814
00815 } // namespace
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


CgFx.h File Reference

#include "nvsg/StateAttribute.h"
#include "nvutil/SWMRSync.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 Fri Aug 4 08:33:26 2006 for NVSGSDK by NVIDIA


CgFx.h Source File

CgFx.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 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/StateAttribute.h"
00015 #include "nvutil/SWMRSync.h"
00016
00017 #include "Cg/cg.h"
00018
00019 #include <vector>
00020 #include <set>
00021
00022 namespace nvsg
00023 {
00024 // forward declaration of internal types
00025 class CgFx;
00026 class TextureImage;
00027 class CgFxEffectHandle;
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
00066 class CgFxEffect : public nvutil::ISWMRSync
00067 {
00068   friend class CgFx;
00069
00070 public:
00071
00081   enum TransformType
00082   {
00084     TRAFO_UNKNOWN = -1,
00086     TRAFO_WORLD = 0,
00088     TRAFO_MODEL                 = TRAFO_WORLD,
00090     TRAFO_VIEW,
00092     TRAFO_PROJECTION,
00094     TRAFO_WORLDT,
00096     TRAFO_MODELT                = TRAFO_WORLDT,
00098     TRAFO_VIEWT,
00100     TRAFO_PROJECTIONT,
00102     TRAFO_WORLDI,
00104     TRAFO_MODELI                = TRAFO_WORLDI,
00106     TRAFO_VIEWI,
00108     TRAFO_PROJECTIONI,
00110     TRAFO_WORLDIT,
00112     TRAFO_MODELIT               = TRAFO_WORLDIT,
00114     TRAFO_VIEWIT,
00116     TRAFO_PROJECTIONIT,
00118     TRAFO_WORLDVIEW,
00120     TRAFO_MODELVIEW             = TRAFO_WORLDVIEW,
00122     TRAFO_WORLDVIEWPROJECTION,
00124     TRAFO_MODELVIEWPROJECTION   = TRAFO_WORLDVIEWPROJECTION,
00126     TRAFO_WORLDVIEWT,
00128     TRAFO_MODELVIEWT            = TRAFO_WORLDVIEWT,
00130     TRAFO_WORLDVIEWPROJECTIONT,
00132     TRAFO_MODELVIEWPROJECTIONT  = TRAFO_WORLDVIEWPROJECTIONT,
00134     TRAFO_WORLDVIEWI,
00136     TRAFO_MODELVIEWI            = TRAFO_WORLDVIEWI,
00138     TRAFO_WORLDVIEWPROJECTIONI,
00140     TRAFO_MODELVIEWPROJECTIONI  = TRAFO_WORLDVIEWPROJECTIONI,
00142     TRAFO_WORLDVIEWIT,
00144     TRAFO_MODELVIEWIT           = TRAFO_WORLDVIEWIT,
00146     TRAFO_WORLDVIEWPROJECTIONIT,
00148     TRAFO_MODELVIEWPROJECTIONIT = TRAFO_WORLDVIEWPROJECTIONIT
00149   };
00150
00151 public:
00191   NVSG_API bool createFromFile(const std::string& file, std::string& err);
00192
00272   NVSG_API bool createFromLump(const std::string& lump, std::string& err);
00273
00288   NVSG_API bool isValid() const;
00289
00302   NVSG_API CGcontext getContext() const;
00303
00316   NVSG_API bool isFromFile() const;
00317
00330   NVSG_API bool isFromLump() const;
00331
00364   NVSG_API bool getFileName(std::string& file) const;
00365
00398   NVSG_API bool getSourceCode(std::string& code) const;
00399
00400   // API concerning annotation queries
00401
00431   NVSG_API size_t getNumberOfParameterAnnotations(CgFxParameter param) const;
00432
00474   NVSG_API CgFxAnnotation getParameterAnnotation(CgFxParameter param, size_t index) const;
00475
00519   NVSG_API CgFxAnnotation getParameterAnnotationByName(CgFxParameter param, const std::string& name) const;
00520
00547   NVSG_API size_t getNumberOfTechniqueAnnotations(CgFxTechnique tech) const;
00548
00587   NVSG_API CgFxAnnotation getTechniqueAnnotation(CgFxTechnique tech, size_t index) const;
00588
00629   NVSG_API CgFxAnnotation getTechniqueAnnotationByName(CgFxTechnique tech, const std::string& name) const;
00630
00656   NVSG_API size_t getNumberOfPassAnnotations(CgFxPass pass) const;
00657
00696   NVSG_API CgFxAnnotation getPassAnnotation(CgFxPass pass, size_t index) const;
00697
00738   NVSG_API CgFxAnnotation getPassAnnotationByName(CgFxPass pass, const std::string& name) const;
00739
00758   NVSG_API const std::string& getAnnotationName(CgFxAnnotation anno) const;
00759
00776   NVSG_API const std::string& getAnnotationTypeString(CgFxAnnotation anno) const;
00777
00825   NVSG_API bool isFloatAnnotation(CgFxAnnotation anno) const;
00826
00874   NVSG_API bool isIntAnnotation(CgFxAnnotation anno) const;
00875
00923   NVSG_API bool isBoolAnnotation(CgFxAnnotation anno) const;
00924
00960   NVSG_API bool isStringAnnotation(CgFxAnnotation anno) const;
00961
00981   NVSG_API size_t getAnnotationValueSize(CgFxAnnotation anno) const;
00982
01005   NVSG_API size_t getNumberOfAnnotationValueComponents(CgFxAnnotation anno) const;
01006
01034   NVSG_API bool getFloatAnnotationValue(CgFxAnnotation anno, float * value) const;
01035
01063   NVSG_API bool getIntAnnotationValue(CgFxAnnotation anno, int * value) const;
01064
01093   NVSG_API bool getBoolAnnotationValue(CgFxAnnotation anno, int * value) const;
01094
01114   NVSG_API bool getStringAnnotationValue(CgFxAnnotation anno, std::string& value) const;
01115
01129   NVSG_API const std::string& getParameterName(CgFxParameter param) const;
01130
01144   NVSG_API const std::string& getParameterSemantic(CgFxParameter param) const;
01145
01160   NVSG_API const std::string& getParameterTypeString(CgFxParameter param) const;
01161
01222   NVSG_API CgFxParameter getParameterByName(const std::string& name) const;
01223
01236   NVSG_API CgFxParameter getParameterBySemantic(const std::string& semantic) const;
01237
01251   NVSG_API size_t getNumberOfArrayParameterElements(CgFxParameter param) const;
01252
01271   NVSG_API CgFxParameter getArrayParameterElement(CgFxParameter param, size_t index) const;
01272
01287   NVSG_API size_t getNumberOfStructParameterMembers(CgFxParameter param) const;
01288
01311   NVSG_API CgFxParameter getStructParameterMember(CgFxParameter param, size_t index) const;
01312
01368   NVSG_API CgFxParameter getStructParameterMemberByName(CgFxParameter param, const std::string& member) const;
01369
01391   NVSG_API size_t getParameterValueSize(CgFxParameter param) const;
01392
01394
01410   NVSG_API size_t getNumberOfParameterValueComponents(CgFxParameter param) const;
01411
01423   NVSG_API bool isScalarParameter(CgFxParameter param) const;
01424
01436   NVSG_API bool isVector2Parameter(CgFxParameter param) const;
01437
01449   NVSG_API bool isVector3Parameter(CgFxParameter param) const;
01450
01462   NVSG_API bool isVector4Parameter(CgFxParameter param) const;
01463
01475   NVSG_API bool isMatrix22Parameter(CgFxParameter param) const;
01476
01488   NVSG_API bool isMatrix23Parameter(CgFxParameter param) const;
01489
01501   NVSG_API bool isMatrix24Parameter(CgFxParameter param) const;
01502
01514   NVSG_API bool isMatrix32Parameter(CgFxParameter param) const;
01515
01527   NVSG_API bool isMatrix33Parameter(CgFxParameter param) const;
01528
01540   NVSG_API bool isMatrix34Parameter(CgFxParameter param) const;
01541
01553   NVSG_API bool isMatrix42Parameter(CgFxParameter param) const;
01554
01566   NVSG_API bool isMatrix43Parameter(CgFxParameter param) const;
01567
01579   NVSG_API bool isMatrix44Parameter(CgFxParameter param) const;
01580
01592   NVSG_API bool isFloatParameter(CgFxParameter param) const;
01593
01605   NVSG_API bool isIntParameter(CgFxParameter param) const;
01606
01618   NVSG_API bool isBoolParameter(CgFxParameter param) const;
01619
01631   NVSG_API bool isStringParameter(CgFxParameter param) const;
01632
01647   NVSG_API bool isSamplerParameter(CgFxParameter param) const;
01648
01664   NVSG_API bool isSampler1DParameter(CgFxParameter param) const;
01665
01681   NVSG_API bool isSampler2DParameter(CgFxParameter param) const;
01682
01698   NVSG_API bool isSampler3DParameter(CgFxParameter param) const;
01699
01715   NVSG_API bool isSamplerRectParameter(CgFxParameter param) const;
01716
01731   NVSG_API bool isSamplerCubeParameter(CgFxParameter param) const;
01732
01750   NVSG_API bool isLightParameter(CgFxParameter param) const;
01751
01767   NVSG_API bool isLightArrayParameter(CgFxParameter param) const;
01768
01786   NVSG_API bool isMaterialParameter(CgFxParameter param) const;
01787
01891   NVSG_API bool isTransformParameter(CgFxParameter param) const;
01892
01901   NVSG_API bool isArrayParameter(CgFxParameter param) const;
01902
01912   NVSG_API bool isStructParameter(CgFxParameter param) const;
01913
01924   NVSG_API size_t getNumberOfTransforms() const;
01925
01927
01956   NVSG_API CgFxParameter getTransform(size_t index) const;
01957
01972   NVSG_API TransformType getTransformType(CgFxParameter param) const;
01973
01992   NVSG_API bool setTransformValue(CgFxParameter param, const float * value);
01993
02007   NVSG_API size_t getNumberOfTweakables() const;
02008
02021   NVSG_API CgFxParameter getTweakable(size_t index) const;
02022
02034   NVSG_API CgFxParameter getTweakableBySemantic(const std::string& semantic) const;
02035
02047   NVSG_API CgFxParameter getTweakableByName(const std::string& name) const;
02048
02057   NVSG_API size_t getNumberOfLights() const;
02058
02085   NVSG_API CgFxParameter getLight(size_t index) const;
02086
02099   NVSG_API CgFxParameter getLightBySemantic(const std::string& semantic) const;
02100
02113   NVSG_API CgFxParameter getLightByName(const std::string& name) const;
02114
02126   NVSG_API CgFxParameter getMaterial() const;
02127
02155   NVSG_API bool getParameterValueAsFloat(CgFxParameter param, float * value) const;
02156
02184   NVSG_API bool setParameterValueAsFloat(CgFxParameter param, const float * value);
02185
02212   NVSG_API bool getFloatParameterValue(CgFxParameter param, float * value) const;
02213
02238   NVSG_API bool setFloatParameterValue(CgFxParameter param, const float* value);
02239
02266   NVSG_API bool getIntParameterValue(CgFxParameter param, int * value) const;
02267
02292   NVSG_API bool setIntParameterValue(CgFxParameter param, const int* value);
02293
02321   NVSG_API bool getBoolParameterValue(CgFxParameter param, int * value) const;
02322
02348   NVSG_API bool setBoolParameterValue(CgFxParameter param, const int* value);
02349
02370   NVSG_API bool getStringParameterValue(CgFxParameter param, std::string& value) const;
02371
02389   NVSG_API bool setStringParameterValue(CgFxParameter param, const std::string& value);
02390
02399   NVSG_API void resetMaterialValues(CgFxParameter param);
02400
02419   NVSG_API bool getMaterialEmissionValue(CgFxParameter param, float * value) const;  // float4
02420
02435   NVSG_API bool setMaterialEmissionValue(CgFxParameter param, const float * value);  // float4
02436
02455   NVSG_API bool getMaterialAmbientValue(CgFxParameter param, float * value) const;   // float4
02456
02471   NVSG_API bool setMaterialAmbientValue(CgFxParameter param, const float * value);   // float4
02472
02491   NVSG_API bool getMaterialDiffuseValue(CgFxParameter param, float * value) const;   // float4
02492
02507   NVSG_API bool setMaterialDiffuseValue(CgFxParameter param, const float * value);   // float4
02508
02527   NVSG_API bool getMaterialSpecularValue(CgFxParameter param, float * value) const;  // float4
02528
02543   NVSG_API bool setMaterialSpecularValue(CgFxParameter param, const float * value);  // float4
02544
02561   NVSG_API bool getMaterialShininessValue(CgFxParameter param, float * value) const; // float
02562
02577   NVSG_API bool setMaterialShininessValue(CgFxParameter param, const float * value); // float
02578
02587   NVSG_API void resetLightValues(CgFxParameter param);
02588
02607   NVSG_API bool getLightAmbientValue(CgFxParameter param, float * value) const;
02608
02623   NVSG_API bool setLightAmbientValue(CgFxParameter param, const float * value);
02624
02643   NVSG_API bool getLightDiffuseValue(CgFxParameter param, float * value) const;
02644
02659   NVSG_API bool setLightDiffuseValue(CgFxParameter param, const float * value);
02660
02679   NVSG_API bool getLightSpecularValue(CgFxParameter param, float * value) const;
02680
02695   NVSG_API bool setLightSpecularValue(CgFxParameter param, const float * value);
02696
02715   NVSG_API bool getLightPositionValue(CgFxParameter param, float * value) const;
02716
02732   NVSG_API bool setLightPositionValue(CgFxParameter param, const float * value);
02733
02752   NVSG_API bool getLightDirectionValue(CgFxParameter param, float * value) const;
02753
02769   NVSG_API bool setLightDirectionValue(CgFxParameter param, const float * value);
02770
02789   NVSG_API bool getLightSpotExponentValue(CgFxParameter param, float * value) const;
02790
02805   NVSG_API bool setLightSpotExponentValue(CgFxParameter param, const float * value);
02806
02825   NVSG_API bool getLightSpotCutoffValue(CgFxParameter param, float * value) const;
02826
02841   NVSG_API bool setLightSpotCutoffValue(CgFxParameter param, const float * value);
02842
02861   NVSG_API bool getLightConstantAttenuationValue(CgFxParameter param, float * value) const;
02862
02877   NVSG_API bool setLightConstantAttenuationValue(CgFxParameter param, const float * value);
02878
02897   NVSG_API bool getLightLinearAttenuationValue(CgFxParameter param, float * value) const;
02898
02913   NVSG_API bool setLightLinearAttenuationValue(CgFxParameter param, const float * value);
02914
02933   NVSG_API bool getLightQuadraticAttenuationValue(CgFxParameter param, float * value) const;
02934
02949   NVSG_API bool setLightQuadraticAttenuationValue(CgFxParameter param, const float * value);
02950
02958   NVSG_API size_t getNumberOfSamplers() const;
02959
02961
02976   NVSG_API CgFxParameter getSampler(size_t index) const;
02977
02989   NVSG_API CgFxParameter getSamplerByName(const std::string& name) const;
02990
03017   NVSG_API CgFxParameter getSamplerByTextureParameterName(const std::string& name) const;
03018
03032   NVSG_API CGparameter getSamplerTexture(CgFxParameter param) const;
03033
03063   NVSG_API bool setSamplerTextureImageSpec(CgFxParameter param, const std::string& file, const TextureImage* image=NULL);
03064
03081   NVSG_API bool getSamplerTextureFileName(CgFxParameter param, std::string& file) const;
03082
03098   NVSG_API const TextureImage * getSamplerTextureImage(CgFxParameter param) const;
03099
03118   NVSG_API const TextureImage * reloadSamplerTextureImage(CgFxParameter param) const;
03119
03140   NVSG_API size_t getNumberOfSamplerStateValueComponents(CgFxParameter param, const std::string& name) const;
03141
03160   NVSG_API bool isFloatSamplerState(CgFxParameter param, const std::string& name) const;
03161
03180   NVSG_API bool isIntSamplerState(CgFxParameter param, const std::string& name) const;
03181
03200   NVSG_API bool isBoolSamplerState(CgFxParameter param, const std::string& name) const;
03201
03213   NVSG_API bool isMipmapSamplerState(CgFxParameter param) const;
03214
03251   NVSG_API bool getFloatSamplerStateValue(CgFxParameter param, const std::string& name, float* value) const;
03252
03289   NVSG_API bool getIntSamplerStateValue(CgFxParameter param, const std::string& name, int* value) const;
03290
03327   NVSG_API bool getBoolSamplerStateValue(CgFxParameter param, const std::string& name, int* value) const;
03328
03349   NVSG_API size_t getNumberOfTechniques() const;
03350
03364   NVSG_API CgFxTechnique getTechnique(size_t index) const;
03365
03379   NVSG_API CgFxTechnique getTechniqueByName(const std::string& name) const;
03380
03394   NVSG_API const std::string& getTechniqueName(CgFxTechnique tech) const;
03395
03405   NVSG_API CgFxTechnique getCurrentTechnique() const;
03406
03419   NVSG_API void setCurrentTechnique(CgFxTechnique tech);
03420
03431   NVSG_API bool validateCurrentTechnique();
03432
03449   NVSG_API size_t getNumberOfPasses(CgFxTechnique tech) const;
03450
03469   NVSG_API CgFxPass getPass(CgFxTechnique tech, size_t index) const;
03470
03491   NVSG_API CgFxPass getPassByName(CgFxTechnique tech, const std::string& name) const;
03492
03506   NVSG_API const std::string& getPassName(CgFxPass pass) const;
03507
03520   NVSG_API bool isTransparentPass(CgFxPass pass) const;
03521
03567   NVSG_API void applyPass(size_t index);
03568
03582   NVSG_API void resetPass(size_t index);
03583
03603   NVSG_API size_t getNumberOfPassStateValueComponents(CgFxPass pass, const std::string& name) const;
03604
03623   NVSG_API bool isFloatPassState(CgFxPass pass, const std::string& name) const;
03624
03643   NVSG_API bool isIntPassState(CgFxPass pass, const std::string& name) const;
03644
03663   NVSG_API bool isBoolPassState(CgFxPass pass, const std::string& name) const;
03664
03701   NVSG_API bool getFloatPassStateValue(CgFxPass pass, const std::string& name, float* value) const;
03702
03739   NVSG_API bool getIntPassStateValue(CgFxPass pass, const std::string& name, int* value) const;
03740
03777   NVSG_API bool getBoolPassStateValue(CgFxPass pass, const std::string& name, int* value) const;
03778
03786   NVSG_API CgFxProgram getVertexProgram(CgFxPass pass) const;
03787
03795   NVSG_API CgFxProgram getFragmentProgram(CgFxPass pass) const;
03796
03809   NVSG_API bool isProgramCompiled(CgFxProgram prog) const;
03810
03828   NVSG_API bool compileProgram(CgFxProgram prog);
03829
03853   NVSG_API bool setProgramProfile(CgFxProgram prog, const std::string& profile);
03854
03866   NVSG_API const std::string& getProgramProfile(CgFxProgram prog) const;
03867
03881   NVSG_API size_t getNumberOfProgramParameters(CgFxProgram prog) const;
03882
03898   NVSG_API CgFxParameter getProgramParameter(CgFxProgram prog, size_t index) const;
03899
03918   NVSG_API bool isInputProgramParameter(CgFxProgram prog, CgFxParameter param) const;
03919
03938   NVSG_API bool isOutputProgramParameter(CgFxProgram prog, CgFxParameter param) const;
03939
03940 private:
03941   CgFxEffect(const CgFx * attrib);
03942   CgFxEffect(const CgFxEffect&, const CgFx * attrib);
03943   ~CgFxEffect();
03944   CgFxEffect& operator=(const CgFxEffect& rhs);
03945
03946
03947   bool initialize(); // parse effect and fill internal structs
03948   void uninitialize(); // cleanup internal structs
03949
03950   // invalidates transparency containment caches of the owning attribute
03951   void invalidateTransparencyContainment();
03952
03953   template <typename T>
03954   bool getParameterValue(CgFxParameter param, T * value, bool (*testType)(CGtype)) const;
03955   template <typename T>
03956   bool setParameterValue(CgFxParameter param, const T * value, bool (*testType)(CGtype));
03957
03958   // sync cached values with effect
03959   void flush();
03960
03961   // walks all techniques for their passes to unload their vertex and fragment programs
03962   void unloadPrograms();
03963
03964   // tests on equivalency with another effect
03965   bool isEquivalent(const CgFxEffect * rhs) const;
03966
03967 private:
03968   const CgFx * m_attrib; // associated attribute. need this link for cache updates
03969   CgFxEffectHandle * m_effect; // handle to the effect resource
03970
03971   enum SourceType
03972   {
03973     SOURCE_UNKNOWN = 0
03974   , SOURCE_FILE = 1
03975   , SOURCE_LUMP
03976   };
03977
03978   unsigned int m_from; // either SOURCE_FILE or SOURCE_LUMP
03979   std::string * m_source; // either filename or code
03980
03981   // distinguish several parameter traits
03982   enum {
03983     PTRAIT_TRAFO = 0
03984   , PTRAIT_LIGHT
03985   , FIRST_FLUSHABLE = PTRAIT_LIGHT
03986   , PTRAIT_MATERIAL
03987   , PTRAIT_TWEAK
03988   , LAST_FLUSHABLE = PTRAIT_TWEAK
03989   , PTRAIT_SAMPLER
03990   , NUM_PTRAITS
03991   };
03992
03993   std::vector< std::vector<CgFxParameter> > m_params;
03994   std::vector<CgFxTechnique> m_techs;
03995   std::set<CgFxParameter> m_flushList; // unique flush list
03996
03997   CgFxTechnique m_currTech; // current technique
03998   CgFxTechnique m_lastCurrTech; // last current technique - need this to check whether validation is pending
03999 };
04000
04004 class CgFx : public StateAttribute
04005 {
04006 public:
04064   NVSG_API static const CgFx * create();
04065
04106   NVSG_API virtual const CgFx * clone() const;
04107
04116   NVSG_API CgFx& operator=(const CgFx& rhs);
04117
04133   NVSG_API virtual bool isDataShared() const;
04134
04144   NVSG_API virtual DataID getDataID() const;
04145
04172   NVSG_API const CgFxEffect * getEffect() const;
04173
04181   NVSG_API void unloadPrograms();
04182
04188   NVSG_API virtual bool isTransparent() const;
04189
04206   NVSG_API virtual bool isEquivalent(const Object *object, bool ignoreNames, bool deepCompare) const;
04207
04208
04209 protected:
04214   CgFx();
04215
04220   CgFx(const CgFx& rhs);
04221
04227   virtual ~CgFx();
04228
04229 private:
04230   const CgFxEffect * m_effect; // embedded effect
04231 };
04232
04233 } // namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


CullData.h File Reference

#include "nvsgcommon.h"
#include "nvutil/Allocator.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 Fri Aug 4 08:33:28 2006 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
00017 #include  "nvutil/Allocator.h"
00018
00019 namespace nvsg
00020 {
00026   typedef enum
00027   {
00028     CC_OUT,
00029     CC_IN,
00030     CC_PART
00031   } CullCode;
00032
00040   class CullData : public nvutil::IAllocator
00041   {
00042     public:
00046       NVSG_API CullData( CullCode cullCode );
00047
00049       NVSG_API virtual ~CullData( void );
00050
00051     public:
00058       NVSG_API void balance( void );
00059
00070       NVSG_API void addChild( CullData *cd );
00071
00076       NVSG_API const CullData * getChild( size_t i ) const;
00077
00080       NVSG_API CullCode getCullCode( void ) const;
00081
00088       NVSG_API size_t getNumberOfChildren( void ) const;
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     m_children.push_back( cd );
00132   }
00133
00134   inline  const CullData  * CullData::getChild( size_t i ) const
00135   {
00136     NVSG_TRACE();
00137     NVSG_ASSERT( i < m_children.size() );
00138     return( m_children[i] );
00139   }
00140
00141   inline  CullCode  CullData::getCullCode( void ) const
00142   {
00143     NVSG_TRACE();
00144     return( m_cullCode );
00145   }
00146
00147   inline  size_t    CullData::getNumberOfChildren( void ) const
00148   {
00149     NVSG_TRACE();
00150     return( m_children.size() );
00151   }
00152
00153 } //  namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


CullTraverser.h File Reference

#include "nvsgcommon.h"
#include <map>
#include "nvsg/CullData.h"
#include "nvtraverser/ModelViewTraverser.h"
#include "nvsg/ViewState.h"

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 Fri Aug 4 08:33:29 2006 for NVSGSDK by NVIDIA


CullTraverser.h Source File

CullTraverser.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  <map>
00018 #include  "nvsg/CullData.h"
00019 #include  "nvtraverser/ModelViewTraverser.h"
00020 #include  "nvsg/ViewState.h"
00021
00022 // forward declarations
00023 namespace nvsg
00024 {
00025   class Drawable;
00026   class Node;
00027   class GeoNode;
00028   class Group;
00029   class Scene;
00030 }
00031
00032 namespace nvtraverser
00033 {
00048   class CullTraverser : public ModelViewTraverser
00049   {
00050     public:
00051
00052     protected:
00054       NVSG_API CullTraverser();
00055
00059       NVSG_API virtual ~CullTraverser(void);
00060
00067       NVSG_API virtual void doApply( const nvsg::Scene *scene );
00068
00073       NVSG_API virtual nvsg::CullCode cullCode( const nvsg::Drawable *p ) const;
00074
00079       NVSG_API virtual nvsg::CullCode cullCode( const nvsg::Node *p ) const;
00080
00086       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00087
00093       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p );
00094
00100       NVSG_API virtual void handleGroup( const nvsg::Group * p );
00101
00107       NVSG_API virtual void handleLOD( const nvsg::LOD * p );
00108
00114       NVSG_API virtual void handleSwitch( const nvsg::Switch * p );
00115
00121       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00122
00128       NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * p );
00129
00134       NVSG_API virtual void traverseLight( const nvsg::LightSource *p );
00135
00136     private:
00137       typedef std::map<const nvsg::Object*,nvsg::CullData*> ObjectCullMap;
00138
00139     private:
00140       nvsg::CullCode determineCullCode( const nvsg::Drawable *p ) const;
00141       nvsg::CullCode determineCullCode( const nvsg::Node *p ) const;
00142       template<typename ObjType>
00143         nvsg::CullData * determineCullData( const ObjType * p );
00144       bool isPartial( const nvsg::Node * p );
00145       void postTraverseObject( const ObjectCullMap::iterator it, nvsg::CullData *cd );
00146       void registerCullCodes( const nvsg::GeoNode * p );
00147       void registerCullCodes( const nvsg::Group * p );
00148
00149     private:
00150       std::stack<nvsg::CullData *>    m_cullDataStack;
00151       std::stack<ObjectCullMap>       m_objectCullMapStack;
00152       nvsg::CullData                * m_cullTree;
00153   };
00154
00155
00156   inline nvsg::CullCode CullTraverser::determineCullCode( const nvsg::Drawable * p ) const
00157   {
00158     return( cullCode( p ) );
00159   }
00160
00161 }
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


DAL.h File Reference

#include "nvsgcommon.h"
#include <vector>
#include <map>
#include "nvutil/Singleton.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 Fri Aug 4 08:33:31 2006 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 "nvutil/Singleton.h"
00020
00021 namespace nvsg
00022 {
00023 class DALServer;
00024 class DALData;
00025
00027 typedef unsigned long HDAL;
00029 extern const HDAL HDAL_INVALID;
00030
00040 class DALHost
00041 {
00042 #if !defined(DOXYGEN_IGNORE)
00043   friend class DALServer;
00044 #endif
00045
00046 public:
00078   NVSG_API HDAL storeDeviceAbstractionLinkData(unsigned int dataID, DALData * data) const;
00079
00088   NVSG_API void releaseDeviceAbstractionLinkData();
00089
00117   template<typename DALDataType, typename TestFunc>
00118   bool getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *& cache, TestFunc test) const;
00119
00157   NVSG_API DALData * getLastRecentlyUsedDeviceAbstractionLinkData() const;
00158
00159 #if !defined(DOXYGEN_IGNORE)
00160 public:
00161   DALHost();
00162   DALHost(const DALHost&);
00163   ~DALHost();
00164 protected:
00165   DALHost & operator=(const DALHost & rhs) {return *this;}
00166 private:
00167   mutable HDAL m_hDAL;
00168   mutable DALData * m_lastRecentlyUsed;
00169 #endif
00170 };
00171
00178 class DALDataCreator
00179 {
00180 public:
00181 #if !defined(DOXYGEN_IGNORE)
00182   virtual ~DALDataCreator() {}
00183 #endif
00184
00201   virtual void onReleaseDAL(HDAL hDAL) {}
00202
00203 protected:
00204 #if !defined(DOXYGEN_IGNORE)
00205   // DALDataCreator serves as base class only.
00206   DALDataCreator() {}
00207 #endif
00208
00223   NVSG_API void releaseDeviceAbstractionLinkData(HDAL hDAL, unsigned int dataID);
00224 };
00225
00236 class DALData
00237 {
00238 #if !defined(DOXYGEN_IGNORE)
00239   friend class DALServer;
00240   friend class DALDataCreator;
00241   friend class DALHost;
00242 protected:
00243   virtual ~DALData();
00244 #endif
00245
00246 protected:
00254   DALData(DALDataCreator * creator);
00255
00266   virtual void deleteThis() { delete this; }
00267
00268 #if !defined(DOXYGEN_IGNORE)
00269 private:
00270   DALDataCreator * m_creator;
00271   const DALHost * m_host;
00272 #endif
00273 };
00274
00275 #if !defined(DOXYGEN_IGNORE)
00276 // Device Abstraction Link Server - implementation details
00277 class DALServer
00278 {
00279   friend class DALDataCreator;
00280   friend class DALHost;
00281
00282 public:
00283   // Initializes the DALServer at instantiation
00284   DALServer();
00285   // Cleanup after deletion
00286   ~DALServer();
00287 private:
00288   // Attaches the data identified by \a dataID and pointed to by \a data
00289   // to the Device Abstraction Link (DAL) identified by \a hDAL.
00290   // If HDAL_INVALID is passed for \a hDAL, a new DAL will be created first.
00291   // \returns A handle to the Device Abstraction Link or DAL_INVALID if the function fails.
00292   HDAL storeDALData(HDAL hDAL, unsigned int dataID, DALData* data);
00293   // Releases the data identified by \a dataID that was attached to the DAL identified by \a hDAL
00294   // by the creator pointed to by \a creator.
00295   // If 0xFFFFFFFF is passed for \a dataID, all data that was attached to the DAL identified by \a hDAL
00296   // by the creator pointed to by \a creator will be released.
00297   // If NULL is passed for \a creator, all data attached to the DAL identified by \a hDAL will be released
00298   // and the DAL will be deleted afterwards.
00299   void releaseDALData(HDAL hDAL, DALDataCreator * creator=NULL, unsigned int dataID=0xFFFFFFFF);
00300   // Provides all addresses of the data objects identified by \a dataID that are currently stored
00301   // with the DAL identified by \a hDAL.
00302   // The addresses of the data objects will be copied to the vector referenced by \a data.
00303   bool getDALData(HDAL hDAL, unsigned int dataID, std::vector<DALData*>& data) const;
00304
00305   // Calls delete this on the data pointer passed
00306   void deleteDALData(DALData * data);
00307
00308 private:
00309   std::map<HDAL, std::multimap<unsigned int, DALData*> > m_DALMap; // map of DALs
00310   std::vector<HDAL> m_freeHDALs; // free DAL handles can be re-used
00311   HDAL m_hDALNext; // use this if no handle is available for re-use
00312 };
00313
00314 typedef nvutil::Singleton<DALServer> DALS;
00315 #endif // DOXYGEN_IGNORE
00316
00317 inline HDAL DALHost::storeDeviceAbstractionLinkData(unsigned int dataID, DALData * data) const
00318 {
00319   NVSG_ASSERT(data); // do not like bad data
00320   NVSG_ASSERT(data->m_host==NULL); // data must not be hosted by anyone else
00321   m_hDAL = DALS::instance()->storeDALData(m_hDAL, dataID, data);
00322   if ( HDAL_INVALID != m_hDAL )
00323   {
00324     data->m_host = this;
00325     m_lastRecentlyUsed = data;
00326   }
00327   return m_hDAL;
00328 }
00329
00330 inline void DALHost::releaseDeviceAbstractionLinkData()
00331 {
00332   if ( m_hDAL != HDAL_INVALID )
00333   {
00334     DALS::instance()->releaseDALData(m_hDAL);
00335     m_hDAL = HDAL_INVALID;
00336     m_lastRecentlyUsed = NULL;
00337   }
00338 }
00339
00340 template <typename DALDataType, typename TestFunc>
00341 inline bool DALHost::getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *& data, TestFunc test) const
00342 {
00343   std::vector<DALData*> caches;
00344   if ( DALS::instance()->getDALData(m_hDAL, dataID, caches) )
00345   {
00346     for ( std::vector<DALData*>::iterator i = caches.begin(); i!=caches.end(); ++i )
00347     {
00348       data = dynamic_cast<DALDataType*>(*i);
00349       if ( data && test(data) )
00350       {
00351         m_lastRecentlyUsed = data;
00352         return true;
00353       }
00354     }
00355   }
00356   return false;
00357 }
00358
00359 inline DALData * DALHost::getLastRecentlyUsedDeviceAbstractionLinkData() const
00360 {
00361   return m_lastRecentlyUsed;
00362 }
00363
00364 inline void DALDataCreator::releaseDeviceAbstractionLinkData(HDAL hDAL, unsigned int dataID)
00365 {
00366   NVSG_ASSERT(hDAL != HDAL_INVALID);
00367   DALS::instance()->releaseDALData(hDAL, this, dataID);
00368 }
00369
00370 } // namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 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 Fri Aug 4 08:33:31 2006 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 Fri Aug 4 08:33:00 2006 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 Fri Aug 4 08:33:32 2006 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:
00058       NVSG_API static const DepthAttribute * create();
00059
00067       NVSG_API static const DepthAttribute * createFromBase( const StateAttribute &rhs );
00068
00072       NVSG_API virtual const DepthAttribute * clone() const;
00073
00077       NVSG_API nvsg::DepthFunction getDepthFunction() const;
00078
00082       NVSG_API void setDepthFunction( nvsg::DepthFunction df );
00083
00087       NVSG_API bool isDepthWritingEnabled() const;
00088
00092       NVSG_API void setDepthWritingEnabled( bool enabled );
00093
00097       NVSG_API bool isDepthTestingEnabled() const;
00098
00102       NVSG_API void setDepthTestingEnabled( bool enabled );
00103
00113       NVSG_API virtual bool isEquivalent( const Object * p
00114                                         , bool ignoreNames
00115                                         , bool deepCompare ) const;
00116
00123       NVSG_API DepthAttribute & operator=( const DepthAttribute & rhs );
00124
00125     protected:
00129       NVSG_API DepthAttribute();
00130
00137       NVSG_API explicit DepthAttribute( const StateAttribute &rhs );
00138
00143       NVSG_API DepthAttribute( const DepthAttribute &rhs );
00144
00148       NVSG_API virtual ~DepthAttribute();
00149
00150     private:
00151       DepthFunction m_depthFunction;
00152       bool          m_depthTesting;
00153       bool          m_depthWriting;
00154   };
00155
00156   inline DepthFunction DepthAttribute::getDepthFunction() const
00157   {
00158     NVSG_TRACE();
00159     return( m_depthFunction );
00160   }
00161
00162   inline bool DepthAttribute::isDepthTestingEnabled() const
00163   {
00164     NVSG_TRACE();
00165     return( m_depthTesting );
00166   }
00167
00168   inline bool DepthAttribute::isDepthWritingEnabled() const
00169   {
00170     NVSG_TRACE();
00171     return( m_depthWriting );
00172   }
00173
00174 } // namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 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 Fri Aug 4 08:33:33 2006 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
00017 #include "nvtraverser/Traverser.h"
00018
00019 namespace nvtraverser
00020 {
00030   class DestrippingTraverser : public Traverser
00031   {
00032     public:
00035       NVSG_API DestrippingTraverser(void);
00036
00037     protected:
00041       NVSG_API virtual ~DestrippingTraverser(void);
00042
00048       NVSG_API virtual void doApply( const nvsg::Scene * scene );
00049
00056       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p );
00057
00061       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips *p );
00062
00066       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips *p );
00067
00071       NVSG_API virtual void handleTriFans( const nvsg::TriFans *p );
00072
00076       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips *p );
00077
00078     private:
00079       const nvsg::Lines     * createLinesFromLineStrips( const nvsg::LineStrips *p );
00080       const nvsg::Quads     * createQuadsFromQuadStrips( const nvsg::QuadStrips *p );
00081       const nvsg::Triangles * createTrianglesFromTriFans( const nvsg::TriFans *p );
00082       const nvsg::Triangles * createTrianglesFromTriStrips( const nvsg::TriStrips *p );
00083
00084     private:
00085       std::vector<const nvsg::LineStrips *>                     m_lineStrips;
00086       std::map<const nvsg::LineStrips *,const nvsg::Lines *>    m_lineStripsToLines;
00087       std::vector<const nvsg::QuadStrips *>                     m_quadStrips;
00088       std::map<const nvsg::QuadStrips *, const nvsg::Quads *>   m_quadStripsToQuads;
00089       std::vector<const nvsg::TriFans *>                        m_triFans;
00090       std::map<const nvsg::TriFans *,const nvsg::Triangles *>   m_triFansToTriangles;
00091       std::vector<const nvsg::TriStrips *>                      m_triStrips;
00092       std::map<const nvsg::TriStrips *,const nvsg::Triangles *> m_triStripsToTriangles;
00093   };
00094 }
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


DirectedLight.h File Reference

#include "nvsgcommon.h"
#include "nvsg/LightSource.h"
#include "nvmath/Vec3f.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 Fri Aug 4 08:33:33 2006 for NVSGSDK by NVIDIA


DirectedLight.h Source File

DirectedLight.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/LightSource.h"
00018 #include "nvmath/Vec3f.h"
00019
00020 namespace nvsg
00021 {
00027   class DirectedLight : public LightSource
00028   {
00029     public:
00034       NVSG_API static const DirectedLight * create();
00035
00042       NVSG_API static const DirectedLight * createFromBase( const LightSource &rhs );
00043
00047       NVSG_API virtual const DirectedLight * clone() const;
00048
00053       NVSG_API nvmath::Vec3f getDirection() const;
00054
00060       NVSG_API void setDirection( const nvmath::Vec3f & direction );
00061
00067       NVSG_API const nvmath::Quatf & getOrientation() const;
00068
00075       NVSG_API void setOrientation( const nvmath::Quatf & orientation );
00076
00082       NVSG_API DirectedLight & operator=( const DirectedLight & rhs );
00083
00084     protected:
00088       NVSG_API DirectedLight();
00089
00096       NVSG_API explicit DirectedLight( const LightSource &rhs );
00097
00102       NVSG_API DirectedLight( const DirectedLight &rhs );
00103
00108       NVSG_API virtual ~DirectedLight();
00109   };
00110
00111   inline nvmath::Vec3f DirectedLight::getDirection() const
00112   {
00113     NVSG_TRACE();
00114     return m_trafo.getOrientation() * nvmath::Vec3f (0.f, 0.f, -1.f);
00115   }
00116
00117   inline const nvmath::Quatf & DirectedLight::getOrientation() const
00118   {
00119     NVSG_TRACE();
00120     return m_trafo.getOrientation();
00121   }
00122
00123   inline void DirectedLight::setOrientation( const nvmath::Quatf & orientation )
00124   {
00125     NVSG_TRACE();
00126     m_trafo.setOrientation(orientation);
00127     increaseIncarnation();
00128   }
00129
00130 } //  namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


Drawable.h File Reference

#include "nvsgcommon.h"
#include "nvsg/HighlightObject.h"
#include "nvsg/Object.h"
#include "nvmath/Sphere3f.h"
#include "nvutil/Lockable.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 Fri Aug 4 08:33:35 2006 for NVSGSDK by NVIDIA


Drawable.h Source File

Drawable.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/Object.h"
00018 #include "nvmath/Sphere3f.h"
00019 #include "nvutil/Lockable.h"
00020
00021 //  forward declarations
00022 namespace nvsg
00023 {
00024   class GeoNode;
00025 }
00026
00027 namespace nvsg
00028 {
00036   class Drawable : public Object
00037   {
00038     public:
00042       NVSG_API virtual const Drawable * clone( void ) const = 0;
00043
00050       NVSG_API const nvmath::Sphere3f & getBoundingSphere( void ) const;
00051
00059       NVSG_API void invalidateBoundingSphere( void );
00060
00067       NVSG_API virtual size_t getNumberOfFrames( void ) const;
00068
00074       NVSG_API void invalidateNumberOfFrames( void ) const;
00075
00082       NVSG_API size_t getNumberOfOwners( void ) const;
00083
00092       NVSG_API const GeoNode * getOwner( size_t index ) const;
00093
00101       NVSG_API void attachHighlightObject( const HighlightObject* obj = NULL );
00102
00106       NVSG_API const HighlightObject* getHighlightObject( void ) const;
00107
00108     protected:
00113       NVSG_API Drawable( void );
00114
00119       NVSG_API Drawable( const Drawable& );
00120
00125       NVSG_API virtual ~Drawable( void );
00126
00133       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere( void ) const = 0;
00134
00141       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00142
00149       NVSG_API virtual void invalidateIncarnation( void );      // from bottom to top
00150
00159       NVSG_API Drawable & operator=(const Drawable & rhs);
00160
00161     private:
00162       // A Drawable can be the child of more than one parent. The child-to-parent connection
00163       // is used, for example, when invalidating the owner GeoNode's BoundingSphere while
00164       // invalidating the BoundingSphere of a Drawable.
00165       friend class GeoNode;
00166       void addOwner( const GeoNode * node );
00167       void removeOwner( const GeoNode * node );
00168
00169     private:
00170       mutable nvmath::Sphere3f      m_boundingSphere;
00171       mutable bool                  m_boundingSphereValid;
00172       const HighlightObject       * m_highlightObject;
00173       std::vector<const GeoNode*>   m_owners;
00174   };
00175
00176   inline size_t Drawable::getNumberOfOwners( void ) const
00177   {
00178     NVSG_TRACE();
00179     return( m_owners.size() );
00180   }
00181
00182   inline const GeoNode * Drawable::getOwner( size_t index ) const
00183   {
00184     NVSG_TRACE();
00185     NVSG_ASSERT( index < m_owners.size() );
00186     return( m_owners[index] );
00187   }
00188
00189   inline const HighlightObject* Drawable::getHighlightObject( void ) const
00190   {
00191     NVSG_TRACE();
00192     return( m_highlightObject );
00193   }
00194
00195 } // namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 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 Fri Aug 4 08:33:35 2006 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 Fri Aug 4 08:33:00 2006 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 Fri Aug 4 08:33:36 2006 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<size_t n> class Face
00025   {
00026     public:
00032       unsigned int & operator[]( size_t i );
00033
00039       const unsigned int & operator[]( size_t i ) const;
00040
00041     public:
00042       unsigned int m_indices[n];
00043   };
00044
00045   template<size_t n>
00046     inline unsigned int & Face<n>::operator[]( size_t i )
00047   {
00048     NVSG_ASSERT( i < n );
00049     return m_indices[i];
00050   }
00051
00052   template<size_t n>
00053     inline const unsigned int & Face<n>::operator[]( size_t i ) const
00054   {
00055     NVSG_ASSERT( i < n );
00056     return m_indices[i];
00057   }
00058
00059   typedef Face<2> Segment;
00060   typedef Face<3> Face3;
00061   typedef Face<4> Face4;
00062 }
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


FaceAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vec3f.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 Fri Aug 4 08:33:37 2006 for NVSGSDK by NVIDIA


FaceAttribute.h Source File

FaceAttribute.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 "nvmath/Vec3f.h"
00018 #include "nvsg/PrimitiveAttribute.h"
00019 #include "nvutil/BitMask.h"
00020
00021
00022 namespace nvsg
00023 {
00024   class FaceAttribute;
00025
00026   typedef enum
00027   {
00028     FM_POINT,
00029     FM_LINE,
00030     FM_FACE
00031   } FaceMode;
00032
00038   class FaceAttribute : public PrimitiveAttribute
00039   {
00040     public:
00045       NVSG_API static const FaceAttribute * create();
00046
00054       NVSG_API static const FaceAttribute * createFromBase( const PrimitiveAttribute &rhs );
00055
00059       NVSG_API virtual const FaceAttribute * clone() const;
00060
00068       NVSG_API bool isFrontFaceCulling() const;
00069
00076       NVSG_API bool isBackFaceCulling() const;
00077
00088       NVSG_API void setCullMode( bool frontCulling, bool backCulling );
00089
00097       NVSG_API FaceMode getFrontFaceMode() const;
00098
00106       NVSG_API FaceMode getBackFaceMode() const;
00107
00116       NVSG_API void setFaceMode( FaceMode frontMode, FaceMode backMode );
00117
00126       NVSG_API bool isPolygonOffset() const;
00127
00133       NVSG_API float getPolygonOffsetFactor() const;
00134
00140       NVSG_API float getPolygonOffsetUnits() const;
00141
00151       NVSG_API void setPolygonOffset( bool onOff );
00152
00161       NVSG_API void setPolygonOffset( float factor
00162                                     , float units );
00163
00174       NVSG_API bool isTwoSidedLighting() const;
00175
00185       NVSG_API void setTwoSidedLighting( bool onOff );
00186
00193       NVSG_API FaceAttribute & operator=( const FaceAttribute & rhs );
00194
00205       NVSG_API virtual bool isEquivalent( const Object * p
00206                                         , bool ignoreNames
00207                                         , bool deepCompare ) const;
00208
00209     protected:
00213       NVSG_API FaceAttribute();
00214
00221       NVSG_API explicit FaceAttribute( const PrimitiveAttribute &rhs );
00222
00227       NVSG_API FaceAttribute( const FaceAttribute &rhs );
00228
00233       NVSG_API virtual ~FaceAttribute();
00234
00235     private:
00236       bool            m_cullMode[2];
00237       FaceMode        m_faceMode[2];
00238       struct
00239       {
00240         bool  enabled;
00241         float factor;
00242         float units;
00243       }               m_polygonOffset;
00244       bool            m_twoSidedLighting;
00245   };
00246
00247   inline bool FaceAttribute::isFrontFaceCulling() const
00248   {
00249     NVSG_TRACE();
00250     return( m_cullMode[0] );
00251   }
00252
00253   inline bool FaceAttribute::isBackFaceCulling() const
00254   {
00255     NVSG_TRACE();
00256     return( m_cullMode[1] );
00257   }
00258
00259   inline void FaceAttribute::setCullMode( bool frontCulling, bool backCulling )
00260   {
00261     NVSG_TRACE();
00262     m_cullMode[0] = frontCulling;
00263     m_cullMode[1] = backCulling;
00264     increaseIncarnation();
00265   }
00266
00267   inline FaceMode FaceAttribute::getFrontFaceMode() const
00268   {
00269     NVSG_TRACE();
00270     return( m_faceMode[0] );
00271   }
00272
00273   inline FaceMode FaceAttribute::getBackFaceMode() const
00274   {
00275     NVSG_TRACE();
00276     return( m_faceMode[1] );
00277   }
00278
00279   inline void FaceAttribute::setFaceMode( FaceMode frontMode, FaceMode backMode )
00280   {
00281     NVSG_TRACE();
00282     m_faceMode[0] = frontMode;
00283     m_faceMode[1] = backMode;
00284     increaseIncarnation();
00285   }
00286
00287   inline void FaceAttribute::setPolygonOffset( bool onOff )
00288   {
00289     NVSG_TRACE();
00290     m_polygonOffset.enabled = onOff;
00291     increaseIncarnation();
00292   }
00293
00294   inline void FaceAttribute::setPolygonOffset( float factor, float units )
00295   {
00296     NVSG_TRACE();
00297     m_polygonOffset.factor = factor;
00298     m_polygonOffset.units = units;
00299     increaseIncarnation();
00300   }
00301
00302   inline bool FaceAttribute::isPolygonOffset() const
00303   {
00304     NVSG_TRACE();
00305     return( m_polygonOffset.enabled );
00306   }
00307
00308   inline float FaceAttribute::getPolygonOffsetFactor() const
00309   {
00310     NVSG_TRACE();
00311     return( m_polygonOffset.factor );
00312   }
00313
00314   inline float FaceAttribute::getPolygonOffsetUnits() const
00315   {
00316     NVSG_TRACE();
00317     return( m_polygonOffset.units );
00318   }
00319
00320   inline void FaceAttribute::setTwoSidedLighting( bool onOff )
00321   {
00322     NVSG_TRACE();
00323     m_twoSidedLighting = onOff;
00324     increaseIncarnation();
00325   }
00326
00327   inline bool FaceAttribute::isTwoSidedLighting() const
00328   {
00329     NVSG_TRACE();
00330     return( m_twoSidedLighting );
00331   }
00332
00333 } // namespace nvsg
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


FlightCameraManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvui/Manipulator.h"
#include "nvui/KeyInput.h"
#include "nvui/MouseInput.h"
#include "nvmath/Vec3f.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 Fri Aug 4 08:33:38 2006 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
00017 #include "nvui/Manipulator.h"
00018 #include "nvui/KeyInput.h"
00019 #include "nvui/MouseInput.h"
00020 #include "nvmath/Vec3f.h"
00021
00022 namespace nvui
00023 {
00050   class FlightCameraManipulator : public Manipulator
00051   {
00052     public:
00062       NVSG_API FlightCameraManipulator(size_t screenSizeX = 1280, size_t 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 bool isFly();
00124
00132       void setWorldUpVector(nvmath::Vec3f up);
00133
00139       const nvmath::Vec3f& getWorldUpVector();
00140
00148       void setSpeedIncreaseFactor(float factor);
00149
00156       float getSpeedIncreaseFactor();
00157
00165       void setHSensitivity(float sensitivity);
00166
00174       float getHSensitivity();
00175
00184       void setVSensitivity(float sensitivity);
00185
00194       float getVSensitivity();
00195
00200       void setSpeed(float speed);
00201
00205       float getSpeed();
00206
00213       NVSG_API void keyDown(UINT key);
00214
00221       NVSG_API void keyUp( UINT key);
00222
00233       NVSG_API void mouseButtonDown(UINT btn, int x, int y);
00234
00245       NVSG_API void mouseButtonUp(UINT btn, int x, int y);
00246
00254       NVSG_API void mouseMotion(int x, int y);
00255
00256     protected:
00258       static NVSG_API const UINT FLYFORWARD;
00260       static NVSG_API const UINT FLYBACKWARD;
00262       static NVSG_API const UINT INCREASESPEED;
00264       static NVSG_API const UINT DECREASESPEED;
00265
00267       static NVSG_API const float AREAOFPEACE;
00268
00269       UINT  m_ScreenSizeX;
00270       UINT  m_ScreenSizeY;
00271
00272       nvmath::Vec3f m_worldUpVector;
00273
00274       float m_speedIncreaseFactor;
00275       float m_hSensitivity;
00276       float m_vSensitivity;
00277
00278       float m_speed;
00279
00280       nvui::MouseInput m_mouseInput;
00281       nvui::KeyInput   m_keyInput;
00282
00283     private:
00284       bool fly();
00285
00286       bool isFlyForward();
00287       bool isFlyBackward();
00288   };
00289
00290   inline void FlightCameraManipulator::setWorldUpVector(nvmath::Vec3f up)
00291   {
00292     m_worldUpVector = up;
00293   }
00294
00295   inline const nvmath::Vec3f& FlightCameraManipulator::getWorldUpVector()
00296   {
00297     return m_worldUpVector;
00298   }
00299
00300   inline void FlightCameraManipulator::setSpeedIncreaseFactor(float factor)
00301   {
00302     NVSG_ASSERT(fabs(factor) > FLT_EPSILON);
00303     m_speedIncreaseFactor = factor;
00304   }
00305
00306   inline float FlightCameraManipulator::getSpeedIncreaseFactor()
00307   {
00308     return m_speedIncreaseFactor;
00309   }
00310
00311   inline void FlightCameraManipulator::setHSensitivity(float sensitivity)
00312   {
00313     m_hSensitivity = sensitivity;
00314   }
00315
00316   inline float FlightCameraManipulator::getHSensitivity()
00317   {
00318     return m_hSensitivity;
00319   }
00320
00321   inline void FlightCameraManipulator::setVSensitivity(float sensitivity)
00322   {
00323     m_vSensitivity = sensitivity;
00324   }
00325
00326   inline float FlightCameraManipulator::getVSensitivity()
00327   {
00328     return m_vSensitivity;
00329   }
00330
00331   inline void FlightCameraManipulator::setSpeed(float speed)
00332   {
00333     m_speed = speed;
00334   }
00335
00336   inline float FlightCameraManipulator::getSpeed()
00337   {
00338     return m_speed;
00339   }
00340
00341 } //  namespace nvui
Generated on Fri Aug 4 08:33:00 2006 for NVSGSDK by NVIDIA


FramedAnimation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Animation.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 Fri Aug 4 08:33:39 2006 for NVSGSDK by NVIDIA


FramedAnimation.h Source File

FramedAnimation.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/Animation.h"
00017
00018 #if !defined(DOXYGEN_IGNORE)
00019 # if !defined(NDEBUG)
00020 #  ifndef new
00021 #   define new new(__FILE__, __LINE__)
00022 #   define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
00023 #  endif
00024 # endif
00025 #endif //DOXYGEN_IGNORE
00026
00027 namespace nvsg
00028 {
00029   class VNVector;
00030
00038   template<typename T> class FramedAnimation : public Animation<T>
00039   {
00040     public:
00044       static const FramedAnimation<T> * create();
00045
00054       static const FramedAnimation<T> * createFromBase( const Animation<T> & rhs );
00055
00059       virtual const FramedAnimation<T> * clone() const;
00060
00066       virtual size_t getNumberOfFrames() const;
00067
00074       void setNumberOfFrames( size_t nof );
00075
00090       NVSG_API virtual bool isEquivalent( const Object * p
00091                                         , bool ignoreNames
00092                                         , bool deepCompare ) const;
00093
00100       virtual const T & operator[]( size_t i ) const;
00101
00110       T & operator[]( size_t i );
00111
00118       FramedAnimation<T> & operator=( const FramedAnimation<T> & rhs );
00119
00120     protected:
00124       NVSG_API FramedAnimation();
00125
00132       NVSG_API explicit FramedAnimation( const Animation<T> &rhs );
00133
00138       NVSG_API FramedAnimation( const FramedAnimation<T> &rhs );
00139
00144       virtual ~FramedAnimation();
00145
00146     private:
00147       std::vector<T> m_values;
00148   };
00149
00150   template<typename T>
00151     const FramedAnimation<T> * FramedAnimation<T>::create()
00152   {
00153     NVSG_TRACE();
00154     return( new FramedAnimation<T> );
00155   }
00156
00157   template<typename T>
00158     const FramedAnimation<T> * FramedAnimation<T>::createFromBase( const Animation<T> &rhs )
00159   {
00160     NVSG_TRACE();
00161     return( new FramedAnimation<T>( rhs ) );
00162   }
00163
00164   template<typename T>
00165     const FramedAnimation<T> * FramedAnimation<T>::clone() const
00166   {
00167     NVSG_TRACE();
00168     return( new FramedAnimation<T>( *this ) );
00169   }
00170
00171   template<typename T>
00172     void FramedAnimation<T>::setNumberOfFrames( size_t nof )
00173   {
00174     NVSG_TRACE();
00175     m_values.resize( nof );
00176     increaseIncarnation();
00177   }
00178
00179   template<typename T>
00180     T & FramedAnimation<T>::operator[]( size_t i )
00181   {
00182     NVSG_TRACE();
00183     NVSG_ASSERT( i < m_values.size() );
00184     increaseIncarnation();
00185     return( m_values[i] );
00186   }
00187
00188 }
00189
00190 #ifdef _DEFINED_DBGNEW
00191 # undef new
00192 #endif
Generated on Fri Aug 4 08:33:01 2006 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 Fri Aug 4 08:33:40 2006 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
00017 #include "nvsg/CullData.h"
00018 #include "nvtraverser/CullTraverser.h"
00019
00020 namespace nvtraverser
00021 {
00030   class FrustumCullTraverser : public CullTraverser
00031   {
00032     public:
00035       NVSG_API FrustumCullTraverser(void);
00036
00037     protected:
00041       NVSG_API virtual ~FrustumCullTraverser(void);
00042
00050       NVSG_API virtual bool preTraverseRoot( const nvsg::Camera *p, const nvsg::Node *root );
00051
00059       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p );
00060
00066       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p );
00067
00074       NVSG_API virtual nvsg::CullCode cullCode( const nvsg::Drawable *p ) const;
00075
00081       NVSG_API virtual nvsg::CullCode cullCode( const nvsg::Node *p ) const;
00082
00083     private:
00084       //  Determine the CullCode based on a sphere
00085       nvsg::CullCode _cullCode( const nvmath::Sphere3f &sphere ) const;
00086
00087     private:
00088       const nvsg::Camera  * m_camera;
00089       std::stack<float>    m_scaleFactors;
00090   };
00091
00092 }
00093
Generated on Fri Aug 4 08:33:01 2006 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 Fri Aug 4 08:33:41 2006 for NVSGSDK by NVIDIA


GeoNode.h Source File

GeoNode.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/Node.h"
00017 #include "nvsg/VertexAttributeSet.h"
00018 #include <vector>
00019
00020 namespace nvsg
00021 {
00022   class StateSet;
00023   class Drawable;
00024
00035   class GeoNode : public Node
00036   {
00037     public:
00041       NVSG_API static const GeoNode * create();
00042
00050       NVSG_API static const GeoNode * createFromBase( const Node &rhs );
00051
00055       NVSG_API virtual GeoNode * clone() const;
00056
00063       NVSG_API size_t getNumberOfGeometries() const;
00064
00071       NVSG_API size_t getGeometryIndex( const Drawable * drawable ) const;
00072
00079       NVSG_API size_t getGeometryIndex( const StateSet * stateSet ) const;
00080
00091       NVSG_API void addGeometry( const Drawable * drawable
00092                                , const StateSet * stateSet = NULL );
00093
00101       NVSG_API void removeGeometry( const StateSet * stateSet );
00102
00113       NVSG_API void removeGeometry( const Drawable * drawable );
00114
00120       NVSG_API void clearGeometries();
00121
00130       NVSG_API const StateSet * getStateSet( size_t geometryIndex ) const;
00131
00140       NVSG_API const StateSet * getStateSet( const Drawable * drawable ) const;
00141
00151       NVSG_API void replaceStateSet( const StateSet * newStateSet
00152                                    , const StateSet * oldStateSet );
00153
00160       NVSG_API size_t getNumberOfDrawables( size_t geometryIndex ) const;
00161
00170       NVSG_API const Drawable * getDrawable( size_t geometryIndex
00171                                            , size_t drawableIndex ) const;
00172
00183       NVSG_API void replaceDrawable( const Drawable * newDrawable
00184                                    , const Drawable * oldDrawable
00185                                    , const StateSet * stateSet );
00186
00195       NVSG_API void replaceDrawable( const Drawable * newDrawable
00196                                    , const Drawable * oldDrawable );
00197
00199       NVSG_API void clearTexCoords( size_t tu = 0 );
00200
00206       NVSG_API virtual bool containsCgFx() const;
00207
00212       NVSG_API virtual void invalidateCgFxContainment();
00213
00220       NVSG_API virtual size_t getNumberOfFrames() const;
00221
00226       NVSG_API virtual void invalidateNumberOfFrames() const;
00227
00240       NVSG_API virtual bool isEquivalent( const Object * p
00241                                         , bool ignoreNames
00242                                         , bool deepCompare ) const;
00243
00251       NVSG_API GeoNode & operator=(const GeoNode & rhs);
00252
00253     protected:
00256       NVSG_API GeoNode();
00257
00263       NVSG_API explicit GeoNode( const Node &rhs );
00264
00268       NVSG_API GeoNode( const GeoNode& rhs );
00269
00274       NVSG_API virtual ~GeoNode();
00275
00281       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00282
00289       NVSG_API virtual bool determineTransparencyContainment() const;
00290
00298       NVSG_API void invalidateCaches( const StateSet * stateSet
00299                                     , bool insert );
00300
00307       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00308
00309     private:
00310       typedef struct
00311       {
00312         const StateSet                * m_stateSet;
00313         std::vector<const Drawable *>   m_drawables;
00314       } Geometry;
00315
00316     private:
00317       // called from embedded Geometry class which is a friend
00318       void drawableAddOwner(const Drawable * drawable);
00319       void drawableRemoveOwner(const Drawable * drawable);
00320       void stateSetAddOwner(const StateSet* stateSet);
00321       void stateSetRemoveOwner(const StateSet* stateSet);
00322
00323       void copyGeometry( Geometry &lhs, const Geometry &rhs );
00324       void deleteGeometry( size_t gi );
00325       void removeDrawable( Geometry * geometry, const Drawable * drawable );
00326       void removeGeometry( size_t gi );
00327       void replaceDrawable( Geometry * geometry, const Drawable * newDrawable, const Drawable * oldDrawable );
00328
00329     private:
00330       std::vector<Geometry> m_geometries;
00331       //  State caches
00332       mutable bool    m_containsCgFx;
00333       mutable bool    m_containsCgFxValid;
00334       mutable size_t  m_numberOfFrames;
00335       mutable bool    m_numberOfFramesValid;
00336   };
00337
00354   NVSG_API void calculateTangentSpace( const GeoNode * gn
00355                                      , size_t tu = 0
00356                                      , size_t tg = 1
00357                                      , size_t bn = 2
00358                                      , bool overwrite = true );
00359
00365   NVSG_API void generateNormals( const GeoNode * gn );
00366
00380   NVSG_API void generateTexCoords( const GeoNode * gn
00381                                  , TextureCoordType tct
00382                                  , size_t tu = 0
00383                                  , bool overwrite = true );
00384
00385   // - - - - - - - - - - - - - - - - - - - - - - - - -
00386   // inlines
00387   // - - - - - - - - - - - - - - - - - - - - - - - - -
00388
00389   inline const Drawable * GeoNode::getDrawable(size_t geometryIndex, size_t drawableIndex) const
00390   {
00391     NVSG_TRACE();
00392     NVSG_ASSERT(geometryIndex<m_geometries.size());
00393     NVSG_ASSERT(drawableIndex<m_geometries[geometryIndex].m_drawables.size());
00394     return( m_geometries[geometryIndex].m_drawables[drawableIndex] );
00395   }
00396
00397   inline size_t GeoNode::getNumberOfDrawables(size_t geometryIndex) const
00398   {
00399     NVSG_TRACE();
00400     NVSG_ASSERT(geometryIndex<m_geometries.size());
00401     return( m_geometries[geometryIndex].m_drawables.size() );
00402   }
00403
00404   inline size_t GeoNode::getNumberOfGeometries() const
00405   {
00406     NVSG_TRACE();
00407     return( m_geometries.size() );
00408   }
00409
00410   inline const StateSet * GeoNode::getStateSet( size_t geometryIndex ) const
00411   {
00412     NVSG_TRACE();
00413     NVSG_ASSERT(geometryIndex<m_geometries.size());
00414     return( m_geometries[geometryIndex].m_stateSet );
00415   }
00416
00417   inline const StateSet * GeoNode::getStateSet( const Drawable * drawable ) const
00418   {
00419     NVSG_TRACE();
00420     NVSG_ASSERT( drawable );
00421     size_t gi = getGeometryIndex( drawable );
00422     return( ( gi != -1 ) ? m_geometries[gi].m_stateSet : NULL );
00423   }
00424
00425 } //  namespace nvsg
Generated on Fri Aug 4 08:33:01 2006 for NVSGSDK by NVIDIA


GLContext.h File Reference

#include "nvsgcommon.h"
#include "nvgl/nvgl.h"
#include "nvgl/GLStatistics.h"
#include "nvmath/Vec4f.h"
#include "nvutil/RCObject.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.

Typedefs

typedef HDC | DEVICE_CONTEXT
typedef HGLRC | RENDER_CONTEXT

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.

Generated on Fri Aug 4 08:33:42 2006 for NVSGSDK by NVIDIA


GLContext.h Source File

GLContext.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 "nvgl/nvgl.h"
00017 #include "nvgl/GLStatistics.h"
00018 #include "nvmath/Vec4f.h"
00019 #include "nvutil/RCObject.h"
00020 #include <map>
00021 #include <stack>
00022 #include <string>
00023 #include <algorithm>
00024 #include <utility>
00025
00026
00027 // common device context helper data types for Windows and Linux
00028 #if defined(_WIN32)
00029 typedef HDC   DEVICE_CONTEXT;
00030 typedef HGLRC RENDER_CONTEXT;
00031 #elif defined(LINUX)
00032 typedef Drawable   DEVICE_CONTEXT;
00033 typedef GLXContext RENDER_CONTEXT;
00034 #endif
00035
00036 namespace nvsg
00037 {
00038   class DALHost;
00039 }
00040
00041 namespace nvgl
00042 {
00043 class GLFunctions;
00044 class GLObjects;
00045 struct GLTextureCache;
00046 struct GLDisplayListCache;
00047 struct GLArrayBufferCache;
00048 struct GLElementArrayBufferCache;
00049
00050 // common device context helper function for Windows and Linux
00051 #if defined(_WIN32)
00052
00053
00054 # define GET_CURRENT_DC()    WGLGetCurrentDC()
00055
00056
00057 # define GET_CURRENT_RC()    WGLGetCurrentContext()
00058
00059
00060 # define MAKE_CURRENT(DC,RC) WGLMakeCurrent(DC,RC)
00061 #elif defined(LINUX)
00062 # define GET_CURRENT_DC()    GLXGetCurrentDrawable()
00063 # define GET_CURRENT_RC()    GLXGetCurrentContext()
00064 # define MAKE_CURRENT(DC,RC) GLXMakeCurrent(glContext()->getDisplay(),DC,RC)
00065 #else
00066 # error Unsupported Operating System!
00067 #endif
00068
00069 #if !defined(DOXYGEN_IGNORE)
00070 # define GL_CACHING
00071 #endif // DOXYGEN_IGNORE
00072
00074
00087 class GLContext
00088 {
00089   friend NVSG_API void GLAccum( GLenum op, GLfloat value );
00090   friend NVSG_API void GLActiveTexture( GLenum texture );
00091   friend NVSG_API void GLAlphaFunc( GLenum func, GLclampf ref );
00092   friend NVSG_API GLboolean GLAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences );
00093   friend NVSG_API void GLArrayElement( GLint i );
00094   friend NVSG_API void GLBegin( GLenum mode );
00095   friend NVSG_API void GLBeginOcclusionQuery( GLuint id );
00096   friend NVSG_API void GLBeginQuery( GLenum target, GLuint id );
00097   friend NVSG_API void GLBindBuffer(GLenum target, GLuint id);
00098   friend NVSG_API void GLBindProgram( GLenum target, GLuint id );
00099   friend NVSG_API void GLBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap );
00100   friend NVSG_API void GLBindTexture( GLenum target, GLuint texture );
00101   friend NVSG_API void GLBlendFunc( GLenum sfactor, GLenum dfactor );
00102   friend NVSG_API void GLBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha );
00103   friend NVSG_API void GLBufferData( GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage );
00104   friend NVSG_API void GLBufferSubData( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data );
00105   friend NVSG_API void GLCallList( GLuint list );
00106   friend NVSG_API void GLCallLists( GLsizei n, GLenum type, const GLvoid *lists );
00107   friend NVSG_API void GLClear( GLbitfield mask );
00108   friend NVSG_API void GLClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
00109   friend NVSG_API void GLClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
00110   friend NVSG_API void GLClearDepth( GLclampd depth );
00111   friend NVSG_API void GLClearIndex( GLfloat c );
00112   friend NVSG_API void GLClearStencil( GLint s );
00113   friend NVSG_API void GLClientActiveTexture( GLenum texture );
00114   friend NVSG_API void GLClipPlane( GLenum plane, const GLdouble *equation );
00115   friend NVSG_API void GLColor3b( GLbyte red, GLbyte green, GLbyte blue );
00116   friend NVSG_API void GLColor3bv( const GLbyte *v );
00117   friend NVSG_API void GLColor3d( GLdouble red, GLdouble green, GLdouble blue );
00118   friend NVSG_API void GLColor3dv( const GLdouble *v );
00119   friend NVSG_API void GLColor3f( GLfloat red, GLfloat green, GLfloat blue );
00120   friend NVSG_API void GLColor3fv( const GLfloat * v );
00121   friend NVSG_API void GLColor3i( GLint red, GLint green, GLint blue );
00122   friend NVSG_API void GLColor3iv( const GLint * v );
00123   friend NVSG_API void GLColor3s( GLshort red, GLshort green, GLshort blue );
00124   friend NVSG_API void GLColor3sv( const GLshort * v );
00125   friend NVSG_API void GLColor3ub( GLubyte red, GLubyte green, GLubyte blue );
00126   friend NVSG_API void GLColor3ubv( const GLubyte * v );
00127   friend NVSG_API void GLColor3ui( GLuint red, GLuint green, GLuint blue );
00128   friend NVSG_API void GLColor3uiv( const GLuint * v );
00129   friend NVSG_API void GLColor3us( GLushort red, GLushort green, GLushort blue );
00130   friend NVSG_API void GLColor3usv( const GLushort * v );
00131   friend NVSG_API void GLColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha );
00132   friend NVSG_API void GLColor4bv( const GLbyte * v );
00133   friend NVSG_API void GLColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha );
00134   friend NVSG_API void GLColor4dv( const GLdouble * v );
00135   friend NVSG_API void GLColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
00136   friend NVSG_API void GLColor4fv( const GLfloat * v );
00137   friend NVSG_API void GLColor4i( GLint red, GLint green, GLint blue, GLint alpha );
00138   friend NVSG_API void GLColor4iv( const GLint * v );
00139   friend NVSG_API void GLColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha );
00140   friend NVSG_API void GLColor4sv( const GLshort * v );
00141   friend NVSG_API void GLColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
00142   friend NVSG_API void GLColor4ubv( const GLubyte * v );
00143   friend NVSG_API void GLColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha );
00144   friend NVSG_API void GLColor4uiv( const GLuint * v );
00145   friend NVSG_API void GLColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha );
00146   friend NVSG_API void GLColor4usv( const GLushort * v );
00147   friend NVSG_API void GLColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
00148   friend NVSG_API void GLColorMaterial( GLenum face, GLenum mode );
00149   friend NVSG_API void GLColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00150   friend NVSG_API void GLCompressedTexImage1D( GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data );
00151   friend NVSG_API void GLCompressedTexImage2D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data );
00152   friend NVSG_API void GLCompressedTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data );
00153   friend NVSG_API void GLCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type );
00154   friend NVSG_API void GLCopyTexImage1D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border );
00155   friend NVSG_API void GLCopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
00156   friend NVSG_API void GLCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
00157   friend NVSG_API void GLCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
00158   friend NVSG_API void GLCullFace( GLenum mode );
00159   friend NVSG_API void GLCullFaceLock( GLenum mode );
00160   friend NVSG_API void GLCullFaceUnlock( GLenum mode );
00161   friend NVSG_API void GLDeleteBuffers( GLsizei n, const GLuint *buffers );
00162   friend NVSG_API void GLDeleteLists( GLuint list, GLsizei range );
00163   friend NVSG_API void GLDeleteOcclusionQueries( GLsizei n, const GLuint *ids );
00164   friend NVSG_API void GLDeletePrograms( GLsizei n, const GLuint *ids );
00165   friend NVSG_API void GLDeleteQueries( GLsizei n, const GLuint *ids );
00166   friend NVSG_API void GLDeleteTextures( GLsizei n, const GLuint *textures );
00167   friend NVSG_API void GLDepthFunc( GLenum func );
00168   friend NVSG_API void GLDepthMask( GLboolean flag );
00169   friend NVSG_API void GLDepthRange( GLclampd znear, GLclampd zfar );
00170   friend NVSG_API void GLDisable( GLenum cap );
00171   friend NVSG_API void GLDisableBlend( void );
00172   friend NVSG_API void GLDisableClientState( GLenum array );
00173   friend NVSG_API void GLDisableColorArray( void );
00174   friend NVSG_API void GLDisableColorMaterial( void );
00175   friend NVSG_API void GLDisableCullFace( void );
00176   friend NVSG_API void GLDisableCullFaceLock( void );
00177   friend NVSG_API void GLDisableCullFaceUnlock( void );
00178   friend NVSG_API void GLDisableDepthTest( void );
00179   friend NVSG_API void GLDisableFogCoordinateArray( void );
00180   friend NVSG_API void GLDisableNormalArray( void );
00181   friend NVSG_API void GLDisableLighting( void );
00182   friend NVSG_API void GLDisableLightingLock( void );
00183   friend NVSG_API void GLDisableLightingUnlock( void );
00184   friend NVSG_API void GLDisableLineSmooth( void );
00185   friend NVSG_API void GLDisableLineStipple( void );
00186   friend NVSG_API void GLDisableNormalize( void );
00187   friend NVSG_API void GLDisablePointSmooth( void );
00188   friend NVSG_API void GLDisablePolygonOffsetFill( void );
00189   friend NVSG_API void GLDisablePolygonOffsetLine( void );
00190   friend NVSG_API void GLDisablePolygonOffsetPoint( void );
00191   friend NVSG_API void GLDisablePolygonStipple( void );
00192   friend NVSG_API void GLDisableSecondaryColorArray( void );
00193   friend NVSG_API void GLDisableTexture( GLenum target );
00194   friend NVSG_API void GLDisableTextureCoordArray( void );
00195   friend NVSG_API void GLDisableTextureGen( GLenum target );
00196   friend NVSG_API void GLDisableVertexArray( void );
00197   friend NVSG_API void GLDrawArrays( GLenum mode, GLint first, GLsizei count );
00198   friend NVSG_API void GLDrawBuffer( GLenum mode );
00199   friend NVSG_API void GLDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices );
00200   friend NVSG_API void GLDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels );
00201   friend NVSG_API void GLDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
00202   friend NVSG_API void GLEdgeFlagPointer( GLsizei stride, const GLboolean *pointer );
00203   friend NVSG_API void GLEdgeFlag( GLboolean flag );
00204   friend NVSG_API void GLEdgeFlagv( const GLboolean *flag );
00205   friend NVSG_API void GLEnable( GLenum cap );
00206   friend NVSG_API void GLEnableBlend( void );
00207   friend NVSG_API void GLEnableClientState( GLenum array );
00208   friend NVSG_API void GLEnableColorArray( void );
00209   friend NVSG_API void GLEnableColorMaterial( void );
00210   friend NVSG_API void GLEnableCullFace( void );
00211   friend NVSG_API void GLEnableCullFaceLock( void );
00212   friend NVSG_API void GLEnableCullFaceUnlock( void );
00213   friend NVSG_API void GLEnableDepthTest( void );
00214   friend NVSG_API void GLEnableFogCoordinateArray( void );
00215   friend NVSG_API void GLEnableLighting( void );
00216   friend NVSG_API void GLEnableLineSmooth( void );
00217   friend NVSG_API void GLEnableLineStipple( void );
00218   friend NVSG_API void GLEnableNormalArray( void );
00219   friend NVSG_API void GLEnableNormalize( void );
00220   friend NVSG_API void GLEnablePointSmooth( void );
00221   friend NVSG_API void GLEnablePolygonOffsetFill( void );
00222   friend NVSG_API void GLEnablePolygonOffsetLine( void );
00223   friend NVSG_API void GLEnablePolygonOffsetPoint( void );
00224   friend NVSG_API void GLEnablePolygonStipple( void );
00225   friend NVSG_API void GLEnableSecondaryColorArray( void );
00226   friend NVSG_API void GLEnableTexture( GLenum target );
00227   friend NVSG_API void GLEnableTextureCoordArray( void );
00228   friend NVSG_API void GLEnableTextureGen( GLenum target );
00229   friend NVSG_API void GLEnableVertexArray( void );
00230   friend NVSG_API void GLEnd( void );
00231   friend NVSG_API void GLEndList( void );
00232   friend NVSG_API void GLEndOcclusionQuery( void );
00233   friend NVSG_API void GLEndQuery( GLenum target );
00234   friend NVSG_API void GLEvalCoord1d( GLdouble u );
00235   friend NVSG_API void GLEvalCoord1f( GLfloat u );
00236   friend NVSG_API void GLEvalCoord2d( GLdouble u, GLdouble v );
00237   friend NVSG_API void GLEvalCoord2f( GLfloat u, GLfloat v );
00238   friend NVSG_API void GLEvalMesh1( GLenum mode, GLint i1, GLint i2 );
00239   friend NVSG_API void GLEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
00240   friend NVSG_API void GLEvalPoint1( GLint i );
00241   friend NVSG_API void GLEvalPoint2( GLint i, GLint j );
00242   friend NVSG_API void GLFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer );
00243   friend NVSG_API void GLFinish( void );
00244   friend NVSG_API void GLFlush( void );
00245   friend NVSG_API void GLFogCoordPointer( GLenum type, GLsizei stride, const GLvoid *pointer );
00246   friend NVSG_API void GLFogf( GLenum pname, GLfloat param );
00247   friend NVSG_API void GLFogfv( GLenum pname, const GLfloat *params );
00248   friend NVSG_API void GLFogi( GLenum pname, GLint param );
00249   friend NVSG_API void GLFogiv( GLenum pname, const GLint *params );
00250   friend NVSG_API void GLFrontFace( GLenum mode );
00251   friend NVSG_API void GLFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
00252   friend NVSG_API void GLGenBuffers( GLsizei n, GLuint *buffers );
00253   friend NVSG_API GLuint GLGenLists( GLsizei range );
00254   friend NVSG_API void GLGenOcclusionQueries( GLsizei n, GLuint *ids );
00255   friend NVSG_API void GLGenPrograms( GLsizei n, GLuint *ids );
00256   friend NVSG_API void GLGenQueries( GLsizei n, GLuint *ids );
00257   friend NVSG_API void GLGenTextures( GLsizei n, GLuint *textures );
00258   friend NVSG_API void GLGetBooleanv( GLenum pname, GLboolean *params );
00259   friend NVSG_API void GLGetDoublev( GLenum pname, GLdouble *params );
00260   friend NVSG_API void GLGetFloatv( GLenum pname, GLfloat *params );
00261   friend NVSG_API void GLGetIntegerv( GLenum pname, GLint *params );
00262   friend NVSG_API void GLGetClipPlane( GLenum plane, GLdouble *equation );
00263   friend NVSG_API void GLGetLightfv( GLenum light, GLenum pname, GLfloat *params );
00264   friend NVSG_API void GLGetLightiv( GLenum light, GLenum pname, GLint *params );
00265   friend NVSG_API void GLGetMapdv( GLenum target, GLenum query, GLdouble *v );
00266   friend NVSG_API void GLGetMapfv( GLenum target, GLenum query, GLfloat *v );
00267   friend NVSG_API void GLGetMapiv( GLenum target, GLenum query, GLint *v );
00268   friend NVSG_API void GLGetMaterialfv( GLenum face, GLenum pname, GLfloat *params );
00269   friend NVSG_API void GLGetMaterialiv( GLenum face, GLenum pname, GLint *params );
00270   friend NVSG_API GLint GLGetMaxTexCoords( void );
00271   friend NVSG_API GLint GLGetMaxTexUnits( void );
00272   friend NVSG_API GLint GLGetMaxTexImageUnits( void );
00273   friend NVSG_API void GLGetOcclusionQueryuiv( GLuint id, GLenum pname, GLuint *params );
00274   friend NVSG_API void GLGetPixelMapfv( GLenum map, GLfloat *values );
00275   friend NVSG_API void GLGetPixelMapuiv( GLenum map, GLuint *values );
00276   friend NVSG_API void GLGetPixelMapusv( GLenum map, GLushort *values );
00277   friend NVSG_API void GLGetPointerv( GLenum pname, GLvoid* *params );
00278   friend NVSG_API void GLGetPolygonStipple( GLubyte *mask );
00279   friend NVSG_API void GLGetQueryiv( GLenum target, GLenum pname, GLint *params );
00280   friend NVSG_API void GLGetQueryObjectiv( GLuint id, GLenum pname, GLint *params );
00281   friend NVSG_API void GLGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params );
00282   friend NVSG_API const GLubyte * GLGetString( GLenum name );
00283   friend NVSG_API void GLGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params );
00284   friend NVSG_API void GLGetTexEnviv( GLenum target, GLenum pname, GLint *params );
00285   friend NVSG_API void GLGetTexGendv( GLenum coord, GLenum pname, GLdouble *params );
00286   friend NVSG_API void GLGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params );
00287   friend NVSG_API void GLGetTexGeniv( GLenum coord, GLenum pname, GLint *params );
00288   friend NVSG_API void GLGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels );
00289   friend NVSG_API void GLGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params );
00290   friend NVSG_API void GLGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params );
00291   friend NVSG_API void GLGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params );
00292   friend NVSG_API void GLGetTexParameteriv( GLenum target, GLenum pname, GLint *params );
00293   friend NVSG_API void GLHint( GLenum target, GLenum mode );
00294   friend NVSG_API void GLIndexd( GLdouble c );
00295   friend NVSG_API void GLIndexf( GLfloat c );
00296   friend NVSG_API void GLIndexi( GLint c );
00297   friend NVSG_API void GLIndexMask( GLuint mask );
00298   friend NVSG_API void GLIndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer );
00299   friend NVSG_API void GLIndexs( GLshort c );
00300   friend NVSG_API void GLIndexub( GLubyte c );
00301   friend NVSG_API void GLInitNames( void );
00302   friend NVSG_API void GLInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer );
00303   friend NVSG_API GLboolean GLIsBuffer( GLuint name );
00304   friend NVSG_API GLboolean GLIsEnabled( GLenum cap );
00305   friend NVSG_API GLboolean GLIsExtensionAvailable( const std::string& extension );
00306   friend NVSG_API GLboolean GLIsExtensionExported( const std::string& extension );
00307   friend NVSG_API GLboolean GLIsList( GLuint list );
00308   friend NVSG_API GLboolean GLIsOcclusionQuery( GLuint id );
00309   friend NVSG_API GLboolean GLIsProgram( GLuint id );
00310   friend NVSG_API GLboolean GLIsQuery( GLuint id );
00311   friend NVSG_API GLboolean GLIsTexture( GLuint texture );
00312   friend NVSG_API void GLLightAmbient( GLenum light, const GLfloat *params );
00313   friend NVSG_API void GLLightConstantAttenuation( GLenum light, GLfloat param );
00314   friend NVSG_API void GLLightDiffuse( GLenum light, const GLfloat *params );
00315   friend NVSG_API void GLLightf( GLenum light, GLenum pname, GLfloat param );
00316   friend NVSG_API void GLLightfv( GLenum light, GLenum pname, const GLfloat *params );
00317   friend NVSG_API void GLLighti( GLenum light, GLenum pname, GLint param );
00318   friend NVSG_API void GLLightiv( GLenum light, GLenum pname, GLint *params );
00319   friend NVSG_API void GLLightLinearAttenuation( GLenum light, GLfloat param );
00320   friend NVSG_API void GLLightQuadraticAttenuation( GLenum light, GLfloat param );
00321   friend NVSG_API void GLLightSpecular( GLenum light, const GLfloat *params );
00322   friend NVSG_API void GLLightSpotCutoff( GLenum light, GLfloat param );
00323   friend NVSG_API void GLLightSpotDirection( GLenum light, const GLfloat *params );
00324   friend NVSG_API void GLLightSpotExponent( GLenum light, GLfloat param );
00325   friend NVSG_API void GLLightModelf( GLenum pname, GLfloat param );
00326   friend NVSG_API void GLLightModelfv( GLenum pname, const GLfloat *params );
00327   friend NVSG_API void GLLightModeli( GLenum pname, GLint param );
00328   friend NVSG_API void GLLightModeliv( GLenum pname, const GLint *params );
00329   friend NVSG_API void GLLightModelAmbient( const GLfloat * params );
00330   friend NVSG_API void GLLightModelLocalViewer( GLint param );
00331   friend NVSG_API void GLLightModelTwoSide( GLint param );
00332   friend NVSG_API void GLLightModelTwoSideLock( GLint param );
00333   friend NVSG_API void GLLightModelTwoSideUnlock( GLint param );
00334   friend NVSG_API void GLLineStipple( GLint factor, GLushort pattern );
00335   friend NVSG_API void GLLineWidth( GLfloat width );
00336   friend NVSG_API void GLListBase( GLuint base );
00337   friend NVSG_API void GLLoadIdentity( void );
00338   friend NVSG_API void GLLoadMatrixd( const GLdouble *m );
00339   friend NVSG_API void GLLoadMatrixf( const GLfloat *m );
00340   friend NVSG_API void GLLoadTransposedMatrixd( const GLdouble *m );
00341   friend NVSG_API void GLLoadTransposeMatrixf( const GLfloat *m );
00342   friend NVSG_API void GLLoadName( GLuint name );
00343   friend NVSG_API void GLLoadProgram( GLenum target, GLuint id, GLsizei len, const GLubyte *program );
00344   friend NVSG_API void GLLogicOp( GLenum opcode );
00345   friend NVSG_API void GLMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points );
00346   friend NVSG_API void GLMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points );
00347   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 );
00348   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 );
00349   friend NVSG_API GLvoid* GLMapBuffer( GLenum target, GLenum access );
00350   friend NVSG_API void GLMapGrid1d( GLint un, GLdouble u1, GLdouble u2 );
00351   friend NVSG_API void GLMapGrid1f( GLint un, GLfloat u1, GLfloat u2 );
00352   friend NVSG_API void GLMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 );
00353   friend NVSG_API void GLMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 );
00354   friend NVSG_API void GLMaterialAmbient( GLenum face, const GLfloat *params );
00355   friend NVSG_API void GLMaterialAmbientBack( const GLfloat *params );
00356   friend NVSG_API void GLMaterialAmbientFront( const GLfloat *params );
00357   friend NVSG_API void GLMaterialAmbientFrontAndBack( const GLfloat *params );
00358   friend NVSG_API void GLMaterialDiffuse( GLenum face, const GLfloat *params );
00359   friend NVSG_API void GLMaterialDiffuseBack( const GLfloat *params );
00360   friend NVSG_API void GLMaterialDiffuseFront( const GLfloat *params );
00361   friend NVSG_API void GLMaterialDiffuseFrontAndBack( const GLfloat *params );
00362   friend NVSG_API void GLMaterialEmission( GLenum face, const GLfloat *params );
00363   friend NVSG_API void GLMaterialEmissionBack( const GLfloat *params );
00364   friend NVSG_API void GLMaterialEmissionFront( const GLfloat *params );
00365   friend NVSG_API void GLMaterialEmissionFrontAndBack( const GLfloat *params );
00366   friend NVSG_API void GLMaterialf( GLenum face, GLenum pname, GLfloat param );
00367   friend NVSG_API void GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
00368   friend NVSG_API void GLMateriali( GLenum face, GLenum pname, GLint param );
00369   friend NVSG_API void GLMaterialiv( GLenum face, GLenum pname, const GLint *params );
00370   friend NVSG_API void GLMaterialShininess( GLenum face, GLfloat param );
00371   friend NVSG_API void GLMaterialShininessBack( GLfloat param );
00372   friend NVSG_API void GLMaterialShininessFront( GLfloat param );
00373   friend NVSG_API void GLMaterialShininessFrontAndBack( GLfloat param );
00374   friend NVSG_API void GLMaterialSpecular( GLenum face, const GLfloat *params );
00375   friend NVSG_API void GLMaterialSpecularBack( const GLfloat *params );
00376   friend NVSG_API void GLMaterialSpecularFront( const GLfloat *params );
00377   friend NVSG_API void GLMaterialSpecularFrontAndBack( const GLfloat *params );
00378   friend NVSG_API void GLMatrixMode( GLenum mode );
00379   friend NVSG_API void GLMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount );
00380   friend NVSG_API void GLMultiTexCoord2f( GLenum texture, GLfloat tx, GLfloat ty );
00381   friend NVSG_API void GLMultMatrixd( const GLdouble *m );
00382   friend NVSG_API void GLMultMatrixf( const GLfloat *m );
00383   friend NVSG_API void GLMultTransposeMatrixd( const GLdouble *m );
00384   friend NVSG_API void GLMultTransposeMatrixf( const GLfloat *m );
00385   friend NVSG_API void GLNewList( GLuint list, GLenum mode );
00386   friend NVSG_API void GLNormal3b( GLbyte nx, GLbyte ny, GLbyte nz );
00387   friend NVSG_API void GLNormal3bv( const GLbyte *v );
00388   friend NVSG_API void GLNormal3d( GLdouble nx, GLdouble ny, GLdouble nz );
00389   friend NVSG_API void GLNormal3dv( const GLdouble *v );
00390   friend NVSG_API void GLNormal3f( GLfloat nx, GLfloat ny, GLfloat nz );
00391   friend NVSG_API void GLNormal3fv( const GLfloat *v );
00392   friend NVSG_API void GLNormal3i( GLint nx, GLint ny, GLint nz );
00393   friend NVSG_API void GLNormal3iv( const GLint *v );
00394   friend NVSG_API void GLNormal3s( GLshort nx, GLshort ny, GLshort nz );
00395   friend NVSG_API void GLNormal3sv( const GLshort *v );
00396   friend NVSG_API void GLNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer );
00397   friend NVSG_API void GLOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
00398   friend NVSG_API void GLPassThrough( GLfloat token );
00399   friend NVSG_API void GLPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values );
00400   friend NVSG_API void GLPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values );
00401   friend NVSG_API void GLPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values );
00402   friend NVSG_API void GLPixelStoref( GLenum pname, GLfloat param );
00403   friend NVSG_API void GLPixelStorei( GLenum pname, GLint param );
00404   friend NVSG_API void GLPixelTransferf( GLenum pname, GLfloat param );
00405   friend NVSG_API void GLPixelTransferi( GLenum pname, GLint param );
00406   friend NVSG_API void GLPixelZoom( GLfloat xfactor, GLfloat yfactor );
00407   friend NVSG_API void GLPointSize( GLfloat size );
00408   friend NVSG_API void GLPolygonMode( GLenum face, GLenum mode );
00409   friend NVSG_API void GLPolygonModeBack( GLenum mode );
00410   friend NVSG_API void GLPolygonModeFront( GLenum mode );
00411   friend NVSG_API void GLPolygonModeFrontAndBack( GLenum mode );
00412   friend NVSG_API void GLPolygonModeLock( GLenum face, GLenum mode );
00413   friend NVSG_API void GLPolygonModeUnlock( GLenum face, GLenum mode );
00414   friend NVSG_API void GLPolygonOffset( GLfloat factor, GLfloat units );
00415   friend NVSG_API void GLPolygonStipple( const GLubyte *mask );
00416   friend NVSG_API void GLPopAttrib( void );
00417   friend NVSG_API void GLPopClientAttrib( void );
00418   friend NVSG_API void GLPopMatrix( void );
00419   friend NVSG_API void GLPopName( void );
00420   friend NVSG_API void GLPrimitiveRestartIndex( GLuint index );
00421   friend NVSG_API void GLPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities );
00422   friend NVSG_API void GLProgramNamedParameter4f( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
00423   friend NVSG_API void GLPushAttrib( GLbitfield mask );
00424   friend NVSG_API void GLPushClientAttrib( GLbitfield mask );
00425   friend NVSG_API void GLPushMatrix( void );
00426   friend NVSG_API void GLPushName( GLuint name );
00427   friend NVSG_API void GLRasterPos2d( GLdouble x, GLdouble y );
00428   friend NVSG_API void GLRasterPos2f( GLfloat x, GLfloat y );
00429   friend NVSG_API void GLRasterPos2i( GLint x, GLint y );
00430   friend NVSG_API void GLRasterPos2s( GLshort x, GLshort y );
00431   friend NVSG_API void GLRasterPos3d( GLdouble x, GLdouble y, GLdouble z );
00432   friend NVSG_API void GLRasterPos3f( GLfloat x, GLfloat y, GLfloat z );
00433   friend NVSG_API void GLRasterPos3i( GLint x, GLint y, GLint z );
00434   friend NVSG_API void GLRasterPos3s( GLshort x, GLshort y, GLshort z );
00435   friend NVSG_API void GLRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
00436   friend NVSG_API void GLRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
00437   friend NVSG_API void GLRasterPos4i( GLint x, GLint y, GLint z, GLint w );
00438   friend NVSG_API void GLRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w );
00439   friend NVSG_API void GLReadBuffer( GLenum mode );
00440   friend NVSG_API void GLReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels );
00441   friend NVSG_API void GLRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 );
00442   friend NVSG_API void GLRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
00443   friend NVSG_API void GLRecti( GLint x1, GLint y1, GLint x2, GLint y2 );
00444   friend NVSG_API void GLRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 );
00445   friend NVSG_API void GLRenderMode( GLenum mode );
00446   friend NVSG_API void GLRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
00447   friend NVSG_API void GLRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
00448   friend NVSG_API void GLScaled( GLdouble x, GLdouble y, GLdouble z );
00449   friend NVSG_API void GLScalef( GLfloat x, GLfloat y, GLfloat z );
00450   friend NVSG_API void GLScissor( GLint x, GLint y, GLsizei width, GLsizei height );
00451   friend NVSG_API void GLSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00452   friend NVSG_API void GLSelectBuffer( GLsizei size, GLuint *buffer );
00453   friend NVSG_API void GLSetWindowStereoMode( GLboolean displayMode );
00454   friend NVSG_API void GLShadeModel( GLenum mode );
00455   friend NVSG_API void GLStencilFunc( GLenum func, GLint ref, GLuint mask );
00456   friend NVSG_API void GLStencilMask( GLuint mask );
00457   friend NVSG_API void GLStencilOp( GLenum fail, GLenum zfail, GLenum zpass );
00458   friend NVSG_API void GLTexCoord1d( GLdouble s );
00459   friend NVSG_API void GLTexCoord1f( GLfloat s );
00460   friend NVSG_API void GLTexCoord1i( GLint s );
00461   friend NVSG_API void GLTexCoord1s( GLshort s );
00462   friend NVSG_API void GLTexCoord2d( GLdouble s, GLdouble t );
00463   friend NVSG_API void GLTexCoord2f( GLfloat s, GLfloat t );
00464   friend NVSG_API void GLTexCoord2fv( const GLfloat *v );
00465   friend NVSG_API void GLTexCoord2i( GLint s, GLint t );
00466   friend NVSG_API void GLTexCoord2s( GLshort s, GLshort t );
00467   friend NVSG_API void GLTexCoord3d( GLdouble s, GLdouble t, GLdouble r );
00468   friend NVSG_API void GLTexCoord3f( GLfloat s, GLfloat t, GLfloat r );
00469   friend NVSG_API void GLTexCoord3i( GLint s, GLint t, GLint r );
00470   friend NVSG_API void GLTexCoord3s( GLshort s, GLshort t, GLshort r );
00471   friend NVSG_API void GLTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q );
00472   friend NVSG_API void GLTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q );
00473   friend NVSG_API void GLTexCoord4i( GLint s, GLint t, GLint r, GLint q );
00474   friend NVSG_API void GLTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q );
00475   friend NVSG_API void GLTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00476   friend NVSG_API void GLTexEnvf( GLenum target, GLenum pname, GLfloat param );
00477   friend NVSG_API void GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
00478   friend NVSG_API void GLTexEnvi( GLenum target, GLenum pname, GLint param );
00479   friend NVSG_API void GLTexEnviv( GLenum target, GLenum pname, const GLint *params );
00480   friend NVSG_API void GLTexGend( GLenum coord, GLenum pname, GLdouble param );
00481   friend NVSG_API void GLTexGenf( GLenum coord, GLenum pname, GLfloat param );
00482   friend NVSG_API void GLTexGenfv( GLenum coord, GLenum pname, const GLfloat *param );
00483   friend NVSG_API void GLTexGeni( GLenum coord, GLenum pname, GLint param );
00484   friend NVSG_API void GLTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels );
00485   friend NVSG_API void GLTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels );
00486   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);
00487   friend NVSG_API void GLTexParameterf( GLenum target, GLenum pname, GLfloat param );
00488   friend NVSG_API void GLTexParameteri( GLenum target, GLenum pname, GLint param );
00489   friend NVSG_API void GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params );
00490   friend NVSG_API void GLTexParameteriv( GLenum target, GLenum pname, const GLint *params );
00491   friend NVSG_API void GLTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels );
00492   friend NVSG_API void GLTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels );
00493   friend NVSG_API void GLTextureBorderColor( GLenum target, const GLfloat *params );
00494   friend NVSG_API void GLTextureEnvColor( const GLfloat * params );
00495   friend NVSG_API void GLTextureEnvMode( GLint param );
00496   friend NVSG_API void GLTextureMagFilter( GLenum target, GLint param );
00497   friend NVSG_API void GLTextureMinFilter( GLenum target, GLint param );
00498   friend NVSG_API void GLTextureWrapR( GLenum target, GLint param );
00499   friend NVSG_API void GLTextureWrapS( GLenum target, GLint param );
00500   friend NVSG_API void GLTextureWrapT( GLenum target, GLint param );
00501   friend NVSG_API void GLTranslated( GLdouble x, GLdouble y, GLdouble z );
00502   friend NVSG_API void GLTranslatef( GLfloat x, GLfloat y, GLfloat z );
00503   friend NVSG_API GLboolean GLUnmapBuffer( GLenum target );
00504   friend NVSG_API void GLVertex2d( GLdouble x, GLdouble y );
00505   friend NVSG_API void GLVertex2f( GLfloat x, GLfloat y );
00506   friend NVSG_API void GLVertex2i( GLint x, GLint y );
00507   friend NVSG_API void GLVertex2s( GLshort x, GLshort y );
00508   friend NVSG_API void GLVertex3d( GLdouble x, GLdouble y, GLdouble z );
00509   friend NVSG_API void GLVertex3f( GLfloat x, GLfloat y, GLfloat z );
00510   friend NVSG_API void GLVertex3fv( const GLfloat *v );
00511   friend NVSG_API void GLVertex3i( GLint x, GLint y, GLint z );
00512   friend NVSG_API void GLVertex3s( GLshort x, GLshort y, GLshort z );
00513   friend NVSG_API void GLVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
00514   friend NVSG_API void GLVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
00515   friend NVSG_API void GLVertex4i( GLint x, GLint y, GLint z, GLint w );
00516   friend NVSG_API void GLVertex4s( GLshort x, GLshort y, GLshort z, GLshort w );
00517   friend NVSG_API void GLVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00518   friend NVSG_API void GLViewport( GLint x, GLint y, GLsizei width, GLsizei height );
00519 #if defined(_WIN32)
00520   friend NVSG_API BOOL WGLBindTexImage( HPBUFFERARB hPbuffer, int iBuffer );
00521   friend NVSG_API BOOL WGLChoosePixelFormat( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats );
00522   friend NVSG_API HGLRC WGLCreateContext( HDC hdc );
00523   friend NVSG_API HPBUFFERARB WGLCreatePbuffer( HDC hdc, int pixelFormat, int width, int height, const int *attribList );
00524   friend NVSG_API BOOL WGLDeleteContext( HGLRC hglrc );
00525   friend NVSG_API BOOL WGLDestroyPbuffer( HPBUFFERARB hPbuffer );
00526   friend NVSG_API HGLRC WGLGetCurrentContext(void);
00527   friend NVSG_API HDC WGLGetCurrentDC(void);
00528   friend NVSG_API BOOL WGLMakeCurrent( HDC hdc, HGLRC hglrc );
00529   friend NVSG_API HDC WGLGetPbufferDC( HPBUFFERARB hPbuffer );
00530   friend NVSG_API BOOL WGLQueryPbuffer( HPBUFFERARB hPbuffer, int attribute, int *value );
00531   friend NVSG_API int WGLReleasePbufferDC( HPBUFFERARB hPbuffer, HDC hdc );
00532   friend NVSG_API BOOL WGLReleaseTexImage( HPBUFFERARB hPbuffer, int iBuffer );
00533   friend NVSG_API BOOL WGLShareLists( HGLRC hglrc1, HGLRC hglrc2 );
00534   friend NVSG_API BOOL WGLJoinSwapGroupNV(HDC hDC, GLuint group);
00535   friend NVSG_API BOOL WGLBindSwapBarrierNV(GLuint group, GLuint barrier);
00536   friend NVSG_API BOOL WGLQuerySwapGroupNV(HDC hDC, GLuint * group, GLuint * barrier);
00537   friend NVSG_API BOOL WGLQueryMaxSwapGroupsNV(HDC hDC, GLuint * maxGroups, GLuint * maxBarriers);
00538   friend NVSG_API BOOL WGLQueryFrameCountNV(HDC hDC, GLuint * count);
00539   friend NVSG_API BOOL WGLResetFrameCountNV(HDC hDC);
00540   // routines to handle bypassing of WGLCreateContext and WGLDeleteContext
00541   friend NVSG_API void WGLAttachContext(HDC, HGLRC);
00542   friend NVSG_API void WGLDetachContext(HGLRC);
00543 #endif
00544 #if defined(LINUX)
00545   friend NVSG_API GLXContext GLXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
00546   friend NVSG_API void GLXDestroyContext(Display *dpy, GLXContext ctx);
00547   friend NVSG_API GLXContext GLXGetCurrentContext();
00548   friend NVSG_API GLXDrawable GLXGetCurrentDrawable();
00549   friend NVSG_API Bool GLXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx);
00550   // routines to handle bypassing of GLXCreateContext and GLXDestroyContext
00551   friend NVSG_API void GLXAttachContext(Display*, GLXContext);
00552   friend NVSG_API void GLXDetachContext(GLXContext);
00553 #endif
00554
00555 #if !defined(DOXYGEN_IGNORE)
00556
00557   //  uncached versions of otherwise cached functions
00558   friend NVSG_API void _GLDisable( GLenum cap );
00559   friend NVSG_API void _GLDisableClientState( GLenum array );
00560   friend NVSG_API void _GLEnable( GLenum cap );
00561   friend NVSG_API void _GLEnableClientState( GLenum array );
00562   friend NVSG_API void _GLLightf( GLenum light, GLenum pname, GLfloat param );
00563   friend NVSG_API void _GLLightfv( GLenum light, GLenum pname, const GLfloat *params );
00564   friend NVSG_API void _GLLighti( GLenum light, GLenum pname, GLint param );
00565   friend NVSG_API void _GLLightiv( GLenum light, GLenum pname, GLint *params );
00566   friend NVSG_API void _GLLightModelf( GLenum pname, GLfloat param );
00567   friend NVSG_API void _GLLightModelfv( GLenum pname, const GLfloat *params );
00568   friend NVSG_API void _GLLightModeli( GLenum pname, GLint param );
00569   friend NVSG_API void _GLLightModeliv( GLenum pname, const GLint *params );
00570   friend NVSG_API void _GLMaterialf( GLenum face, GLenum pname, GLfloat param );
00571   friend NVSG_API void _GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
00572   friend NVSG_API void _GLMateriali( GLenum face, GLenum pname, GLint param );
00573   friend NVSG_API void _GLMaterialiv( GLenum face, GLenum pname, const GLint *params );
00574   friend NVSG_API void _GLPolygonMode( GLenum face, GLenum mode );
00575   friend NVSG_API void _GLTexEnvf( GLenum target, GLenum pname, GLfloat param );
00576   friend NVSG_API void _GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
00577   friend NVSG_API void _GLTexEnvi( GLenum target, GLenum pname, GLint param );
00578   friend NVSG_API void _GLTexEnviv( GLenum target, GLenum pname, const GLint *params );
00579   friend NVSG_API void _GLTexParameterf( GLenum target, GLenum pname, GLfloat param );
00580   friend NVSG_API void _GLTexParameteri( GLenum target, GLenum pname, GLint param );
00581   friend NVSG_API void _GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params );
00582   friend NVSG_API void _GLTexParameteriv( GLenum target, GLenum pname, const GLint *params );
00583
00584 #if defined( GL_CACHING )
00585   friend NVSG_API void _GLUpdateActiveTexture( void );
00586   friend NVSG_API void _GLUpdateClientActiveTexture( void );
00587 #endif
00588
00589 #if !defined(NDEBUG)
00590   friend NVSG_API void ASSERT_GL_CURRENT_CONTEXT_CONFORMITY();
00591   friend NVSG_API void ASSERT_GL_ARRAY_BUFFER_BINDING();
00592   friend NVSG_API void ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
00593 #endif
00594
00595 #endif
00596
00597   friend NVSG_API void GLGenDisplayListCache(const nvsg::DALHost * host, GLDisplayListCache *& cache);
00598   friend NVSG_API void GLGenArrayBufferCache(const nvsg::DALHost * host, GLArrayBufferCache *& cache);
00599   friend NVSG_API void GLGenElementArrayBufferCache(const nvsg::DALHost * host, GLElementArrayBufferCache *& cache);
00600   friend NVSG_API void GLGenTextureCache(const nvsg::DALHost * host, GLTextureCache *& cache);
00601   friend NVSG_API void GLGenTextureCache(const nvsg::DALHost * host, GLTextureCache *& cache, GLuint texture, GLenum target);
00602
00603 public:  // public interface
00604 #if defined(LINUX)
00605   inline Display* getDisplay() { return m_dpy; }  // public access to the Display
00606 #endif
00607
00608 private: // private interface
00609
00610 #if defined(_WIN32)
00611   GLContext(HDC hdc, HGLRC hglrc);
00612 #elif defined(LINUX)
00613   GLContext(Display *dpy, GLXContext ctx);
00614 #endif
00615   ~GLContext();
00616
00617 #if defined(_WIN32)
00618   void init(); // init function pointers and caches
00619 #elif defined(LINUX)
00620   void init(GLXDrawable drw);
00621 #endif
00622   void exit(); // cleanup when context dies
00623
00624   void deleteGLObjects(); // deletes all GLObjects
00625   void deleteSharedGLObjects(); // deletes only shared GLObjects
00626
00627   // Share sharable GL objects with the GLContext referenced through \a source.
00628   void share(const GLContext& source);
00629
00630   // helper
00631   bool isTexture(GLuint name) const;
00632   bool isVBO(GLuint name)     const;
00633   bool isProgram(GLuint name) const;
00634   bool isDisplayList(GLuint name) const;
00635   bool isOcclusionQuery(GLuint name) const;
00636   bool isQuery(GLuint name) const;
00637
00638   void genTextureCache(const nvsg::DALHost * host, GLTextureCache *& cache);
00639   void genTextureCache(const nvsg::DALHost * host, GLTextureCache *& cache, GLuint texture, GLenum target);
00640   void genDisplayListCache(const nvsg::DALHost * host, GLDisplayListCache *& cache);
00641   void genElementArrayBufferCache(const nvsg::DALHost * host, GLElementArrayBufferCache *& cache);
00642   void genArrayBufferCache(const nvsg::DALHost * host, GLArrayBufferCache *& cache);
00643
00644 private:  //  private members
00645 #if defined( GL_CACHING )
00646   class ColorBufferAttributes
00647   {
00648     public:
00649       ColorBufferAttributes( void );
00650       ColorBufferAttributes( const ColorBufferAttributes &rhs );
00651
00652     public:
00653       GLenum        m_blendSrcRGB;
00654       GLenum        m_blendSrcAlpha;
00655       GLenum        m_blendDstRGB;
00656       GLenum        m_blendDstAlpha;
00657       nvmath::Vec4f m_clearColor;
00658   };
00659
00660   class ColorBufferEnableAttributes
00661   {
00662     public:
00663       ColorBufferEnableAttributes( void );
00664       ColorBufferEnableAttributes( const ColorBufferEnableAttributes &rhs );
00665
00666     public:
00667       bool  m_blend;
00668   };
00669
00670   class DepthBufferAttributes
00671   {
00672     public:
00673       DepthBufferAttributes( void );
00674       DepthBufferAttributes( const DepthBufferAttributes &rhs );
00675
00676     public:
00677       GLenum    m_depthFunc;
00678       GLboolean m_depthWriting;
00679   };
00680
00681   class DepthBufferEnableAttributes
00682   {
00683     public:
00684       DepthBufferEnableAttributes( void );
00685       DepthBufferEnableAttributes( const DepthBufferEnableAttributes &rhs );
00686
00687     public:
00688       GLboolean m_depthTesting;
00689   };
00690
00691   class LightParameters
00692   {
00693     public:
00694       LightParameters( void );
00695       LightParameters( const LightParameters &rhs );
00696
00697     public:
00698       nvmath::Vec4f m_ambient;
00699       nvmath::Vec4f m_diffuse;
00700       nvmath::Vec4f m_specular;
00701       nvmath::Vec3f m_attenuation;
00702       float         m_spotExponent;
00703       float         m_spotCutoff;
00704   };
00705
00706   class LightingAttributes
00707   {
00708     public:
00709       LightingAttributes( void );
00710       LightingAttributes( const LightingAttributes &rhs );
00711
00712     public:
00713       bool                          m_colorMaterial;
00714       bool                          m_lightModelLocalViewer;
00715       bool                          m_lightModelTwoSide;
00716       nvmath::Vec4f                 m_lightModelAmbient;
00717       std::vector<LightParameters>  m_lightParameters;
00718       nvmath::Vec4f                 m_materialAmbient[2];
00719       nvmath::Vec4f                 m_materialDiffuse[2];
00720       nvmath::Vec4f                 m_materialSpecular[2];
00721       nvmath::Vec4f                 m_materialEmission[2];
00722       float                         m_materialShininess[2];
00723   };
00724
00725   class LightingEnableAttributes
00726   {
00727     public:
00728       LightingEnableAttributes( void );
00729       LightingEnableAttributes( const LightingEnableAttributes &rhs );
00730
00731     public:
00732       bool  m_lighting;
00733   };
00734
00735   class LineAttributes
00736   {
00737     public:
00738       LineAttributes( void );
00739       LineAttributes( const LineAttributes &rhs );
00740
00741     public:
00742       float     m_width;
00743       GLushort  m_stipplePattern;
00744       GLint     m_stippleRepeat;
00745   };
00746
00747   class LineEnableAttributes
00748   {
00749     public:
00750       LineEnableAttributes( void );
00751       LineEnableAttributes( const LineEnableAttributes &rhs );
00752
00753     public:
00754       bool  m_smooth;
00755       bool  m_stipple;
00756   };
00757
00758   class PointAttributes
00759   {
00760     public:
00761       PointAttributes( void );
00762       PointAttributes( const PointAttributes &rhs );
00763
00764     public:
00765       float m_size;
00766   };
00767
00768   class PointEnableAttributes
00769   {
00770     public:
00771       PointEnableAttributes( void );
00772       PointEnableAttributes( const PointEnableAttributes &rhs );
00773
00774     public:
00775       bool  m_smooth;
00776   };
00777
00778   class PolygonAttributes
00779   {
00780     public:
00781       PolygonAttributes( void );
00782       PolygonAttributes( const PolygonAttributes &rhs );
00783
00784     public:
00785       GLenum  m_cullFaceMode;
00786       GLenum  m_frontFaceMode;
00787       GLenum  m_rasterMode[2];
00788       GLfloat m_offsetFactor;
00789       GLfloat m_offsetBias;
00790   };
00791
00792   class PolygonEnableAttributes
00793   {
00794     public:
00795       PolygonEnableAttributes( void );
00796       PolygonEnableAttributes( const PolygonEnableAttributes &rhs );
00797
00798     public:
00799       bool  m_cullFace;
00800       bool  m_offsetFill;
00801       bool  m_offsetLine;
00802       bool  m_offsetPoint;
00803       bool  m_stipple;
00804   };
00805
00806   class TextureAttributesPerUnit
00807   {
00808     public:
00809       TextureAttributesPerUnit( void );
00810       TextureAttributesPerUnit( const TextureAttributesPerUnit &rhs );
00811
00812     public:
00813       nvmath::Vec4f                       m_envColor;
00814       GLenum                              m_envMode;
00815   };
00816
00817   class TextureAttributes
00818   {
00819     public:
00820       TextureAttributes( void );
00821       TextureAttributes( const TextureAttributes &rhs );
00822
00823     public:
00824       std::vector<TextureAttributesPerUnit> m_unit;
00825       GLenum                                m_active;
00826       GLenum                                m_toActivate;
00827   };
00828
00829   class TextureEnableAttributesPerUnit
00830   {
00831     public:
00832       TextureEnableAttributesPerUnit( void );
00833       TextureEnableAttributesPerUnit( const TextureEnableAttributesPerUnit &rhs );
00834
00835     public:
00836       std::map<GLenum,bool> m_texture;  // texture enable per target
00837       GLenum                m_gen[4];
00838   };
00839
00840   class TextureEnableAttributes
00841   {
00842     public:
00843       TextureEnableAttributes( void );
00844       TextureEnableAttributes( const TextureEnableAttributes &rhs );
00845
00846     public:
00847       std::vector<TextureEnableAttributesPerUnit> m_unit;
00848   };
00849
00850   class TransformAttributes
00851   {
00852     public:
00853       TransformAttributes( void );
00854       TransformAttributes( const TransformAttributes &rhs );
00855
00856     public:
00857       GLenum  m_matrixMode;
00858   };
00859
00860   class TransformEnableAttributes
00861   {
00862     public:
00863       TransformEnableAttributes( void );
00864       TransformEnableAttributes( const TransformEnableAttributes &rhs );
00865
00866     public:
00867       bool  m_normalize;
00868   };
00869
00870   class VertexArrayParameters
00871   {
00872     public:
00873       VertexArrayParameters( void );
00874       VertexArrayParameters( GLint size, GLenum type, GLsizei stride, const GLvoid * pointer );
00875       VertexArrayParameters( const VertexArrayParameters &rhs );
00876
00877     public:
00878       void invalidate( void );
00879       bool operator!=( const VertexArrayParameters &rhs );
00880
00881     public:
00882       GLint           m_size;
00883       GLenum          m_type;
00884       GLsizei         m_stride;
00885       const GLvoid *  m_pointer;
00886   };
00887
00888   class VertexArrayAttributes
00889   {
00890     public:
00891       VertexArrayAttributes( void );
00892       VertexArrayAttributes( const VertexArrayAttributes &rhs );
00893
00894     public:
00895       bool                                m_vertexArray;
00896       bool                                m_normalArray;
00897       bool                                m_colorArray;
00898       bool                                m_secondaryColorArray;
00899       bool                                m_fogCoordArray;
00900       std::vector<bool>                   m_textureCoordArray;
00901       VertexArrayParameters               m_vertexArrayParams;
00902       VertexArrayParameters               m_normalArrayParams;
00903       VertexArrayParameters               m_colorArrayParams;
00904       VertexArrayParameters               m_secondaryColorArrayParams;
00905       VertexArrayParameters               m_fogCoordArrayParams;
00906       std::vector<VertexArrayParameters>  m_textureCoordArrayParams;
00907       GLuint                              m_primitiveRestartIndex;
00908       GLenum                              m_clientTextureActive;
00909       GLenum                              m_clientTextureToActivate;
00910       GLint                               m_bufferBinding[2];
00911   };
00912
00913   ColorBufferAttributes       m_colorBufferAttributes;
00914   ColorBufferEnableAttributes m_colorBufferEnableAttributes;
00915   DepthBufferAttributes       m_depthBufferAttributes;
00916   DepthBufferEnableAttributes m_depthBufferEnableAttributes;
00917   LightingAttributes          m_lightingAttributes;
00918   LightingEnableAttributes    m_lightingEnableAttributes;
00919   LineAttributes              m_lineAttributes;
00920   LineEnableAttributes        m_lineEnableAttributes;
00921   PointAttributes             m_pointAttributes;
00922   PointEnableAttributes       m_pointEnableAttributes;
00923   PolygonAttributes           m_polygonAttributes;
00924   PolygonEnableAttributes     m_polygonEnableAttributes;
00925   TextureAttributes           m_textureAttributes;
00926   TextureEnableAttributes     m_textureEnableAttributes;
00927   TransformAttributes         m_transformAttributes;
00928   TransformEnableAttributes   m_transformEnableAttributes;
00929   VertexArrayAttributes       m_vertexArrayAttributes;
00930
00931   std::stack<GLbitfield>                  m_pushMasks;
00932   std::stack<GLbitfield>                  m_clientPushMasks;
00933   std::stack<ColorBufferAttributes>       m_colorBufferAttributesStack;
00934   std::stack<ColorBufferEnableAttributes> m_colorBufferEnableAttributesStack;
00935   std::stack<DepthBufferAttributes>       m_depthBufferAttributesStack;
00936   std::stack<DepthBufferEnableAttributes> m_depthBufferEnableAttributesStack;
00937   std::stack<LightingAttributes>          m_lightingAttributesStack;
00938   std::stack<LightingEnableAttributes>    m_lightingEnableAttributesStack;
00939   std::stack<LineAttributes>              m_lineAttributesStack;
00940   std::stack<LineEnableAttributes>        m_lineEnableAttributesStack;
00941   std::stack<PointAttributes>             m_pointAttributesStack;
00942   std::stack<PointEnableAttributes>       m_pointEnableAttributesStack;
00943   std::stack<PolygonAttributes>           m_polygonAttributesStack;
00944   std::stack<PolygonEnableAttributes>     m_polygonEnableAttributesStack;
00945   std::stack<TextureAttributes>           m_textureAttributesStack;
00946   std::stack<TextureEnableAttributes>     m_textureEnableAttributesStack;
00947   std::stack<TransformAttributes>         m_transformAttributesStack;
00948   std::stack<TransformEnableAttributes>   m_transformEnableAttributesStack;
00949   std::stack<VertexArrayAttributes>       m_vertexArrayAttributesStack;
00950
00951 #endif // GL_CACHING
00952   GLObjects     * m_glObjects;    // Handling of shareable and non-shareable objects
00953
00954   class GLLocks
00955   {
00956     public:
00957       GLLocks( void );
00958
00959     public:
00960       bool  m_cullFace;
00961       bool  m_cullFaceMode;
00962       bool  m_lighting;
00963       bool  m_lightModelTwoSide;
00964       bool  m_polygonMode;
00965   };
00966
00967   GLLocks         m_locks;
00968
00969 #if defined(_WIN32)
00970   HDC             m_hdc;        // Handle to the corresponding device context
00971   HGLRC           m_hglrc;      // Handle of the corresponding GL render context
00972 #elif defined(LINUX)
00973   static Display * m_dpy;       // Handle to corresponding X display
00974   GLXContext       m_ctx;       // Handle to corresponding X render context
00975   GLXDrawable      m_drawable;  // Handle to corresponding X drawable
00976 #endif
00977
00978   GLFunctions   * m_glFunctions;  // Pointer to OpenGL functions wrapper object
00979   GLint           m_maxTexCoords; // Maximal number of supported client texture slots on this HW
00980   GLint           m_maxTexUnits;  // Maximal number of supported texture slots on this HW
00981   GLint           m_maxTexImageUnits;  // Maximal number of supported texture image units on this HW
00982 #if !defined(NDEBUG)
00983   bool            m_inBeginEndLoop;  // \c true, when inside a glBegin/glEnd loop, otherwise \c false
00984 #endif
00985 #if defined( GL_STATISTICS )
00986   GLStatistics  * m_glStats;
00987 #endif
00988 };
00989
00990 } // namespace nvgl
00991
00992 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00993 // inline implementations
00994 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00995
00996 // need defines now with implementing
00997 #include "nvgl/GLFunctions.h"
00998 #include "nvgl/GLObjects.h"
00999
01000 namespace nvgl
01001 {
01002
01003 inline GLContext * glContext()
01004 {
01005 #if defined(_WIN32)
01006   NVSG_ASSERT(glContextTlsIdx!=TLS_OUT_OF_INDEXES);
01007   return (GLContext*)TlsGetValue(glContextTlsIdx);
01008 #elif defined(LINUX)
01009   return (GLContext*)pthread_getspecific(glContextKey);
01010 #else
01011 #error Unsupported Operating System!
01012 #endif
01013 }
01014
01016 #if !defined(DOXYGEN_IGNORE)
01017 # if !defined(NDEBUG)
01018 inline void ASSERT_GL_CURRENT_CONTEXT_CONFORMITY()
01019 {
01020 #  if defined(_WIN32)
01021   HGLRC hglrc = wglGetCurrentContext();
01022   NVSG_ASSERT((glContext()!=NULL)==(hglrc!=NULL));
01023   NVSG_ASSERT(!glContext()||glContext()->m_hglrc==hglrc);
01024 #  elif defined(LINUX)
01025   GLXContext ctx = glXGetCurrentContext();
01026   NVSG_ASSERT((glContext()!=NULL)==(ctx!=NULL));
01027   NVSG_ASSERT(!glContext()||glContext()->m_ctx==ctx);
01028 #  else // unsupported OS
01029 #  endif
01030 }
01031 # else
01032 # define ASSERT_GL_CURRENT_CONTEXT_CONFORMITY() static_cast<void*>(0)
01033 # endif
01034
01035 # if !defined(NDEBUG) && defined(GL_CACHING)
01036
01037 inline void ASSERT_GL_ARRAY_BUFFER_BINDING()
01038 {
01039   GLContext * ctx = glContext();
01040   GLint name;
01041   GLGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &name);
01042   NVSG_ASSERT(ctx->m_vertexArrayAttributes.m_bufferBinding[0]==name);
01043 }
01044
01045 inline void ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING()
01046 {
01047   GLContext * ctx = glContext();
01048   GLint name;
01049   GLGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &name);
01050   NVSG_ASSERT(ctx->m_vertexArrayAttributes.m_bufferBinding[1]==name);
01051 }
01052
01053 # else
01054
01055 # define ASSERT_GL_ARRAY_BUFFER_BINDING() static_cast<void*>(0)
01056 # define ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING() static_cast<void*>(0)
01057
01058 # endif
01059 #endif //DOXYGEN_IGNORE
01060
01062 inline bool equalf(GLfloat a, GLfloat b)
01063 {
01064   return (*((int*)&a) == *((int*)&b));
01065 }
01067 inline bool equal3f(GLfloat a1, GLfloat a2, GLfloat a3, const GLfloat *b)
01068 {
01069   return (  *((int*)&a1) == *((int*)&b[0])
01070          && *((int*)&a2) == *((int*)&b[1])
01071          && *((int*)&a3) == *((int*)&b[2]));
01072 }
01074 inline bool equal3fv(const GLfloat *a, const GLfloat *b)
01075 {
01076   return (  *((int*)&a[0]) == *((int*)&b[0])
01077          && *((int*)&a[1]) == *((int*)&b[1])
01078          && *((int*)&a[2]) == *((int*)&b[2]));
01079 }
01081 inline bool equal4f(GLfloat a1, GLfloat a2, GLfloat a3, GLfloat a4, const GLfloat *b)
01082 {
01083   return (  *((int*)&a1) == *((int*)&b[0])
01084          && *((int*)&a2) == *((int*)&b[1])
01085          && *((int*)&a3) == *((int*)&b[2])
01086          && *((int*)&a4) == *((int*)&b[3]));
01087 }
01089 inline bool equal4fv(const GLfloat *a, const GLfloat *b)
01090 {
01091   return (  *((int*)&a[0]) == *((int*)&b[0])
01092          && *((int*)&a[1]) == *((int*)&b[1])
01093          && *((int*)&a[2]) == *((int*)&b[2])
01094          && *((int*)&a[3]) == *((int*)&b[3]));
01095 }
01096
01098
01100
01101 inline void  GLAccum( GLenum op, GLfloat value )
01102 {
01103   NVSG_GL_STATS_FCT_COUNT();
01104   glAccum( op, value );
01105   ASSERT_GL_NO_ERROR;
01106 }
01107
01109
01110 inline  void  GLActiveTexture( GLenum texture )
01111 {
01112 #if defined( GL_CACHING )
01113   glContext()->m_textureAttributes.m_toActivate = texture - GL_TEXTURE0;
01114 #else
01115   NVSG_GL_STATS_ACTIVE_TEXTURE( texture );
01116   glContext()->m_glFunctions->glActiveTexture(texture);
01117   ASSERT_GL_NO_ERROR;
01118 #endif
01119 }
01120
01122
01123 inline  void  GLAlphaFunc( GLenum func, GLclampf ref )
01124 {
01125   NVSG_GL_STATS_FCT_COUNT();
01126   glAlphaFunc( func, ref );
01127   ASSERT_GL_NO_ERROR;
01128 }
01129
01131
01132 inline  GLboolean GLAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
01133 {
01134   NVSG_GL_STATS_FCT_COUNT();
01135   GLboolean ok = glAreTexturesResident( n, textures, residences );
01136   ASSERT_GL_NO_ERROR;
01137   return( ok );
01138 }
01139
01141
01142 inline  void  GLArrayElement( GLint i )
01143 {
01144   NVSG_GL_STATS_FCT_COUNT();
01145   glArrayElement( i );
01146   ASSERT_GL_NO_ERROR;
01147 }
01148
01150
01151 inline  void  GLBegin( GLenum mode )
01152 {
01153   NVSG_GL_STATS_FCT_COUNT();
01154   glBegin( mode );
01155 #if !defined(NDEBUG)
01156   glContext()->m_inBeginEndLoop = true;
01157 #endif
01158 }
01159
01161
01163 inline  void  GLBeginOcclusionQuery( GLuint id )
01164 {
01165   NVSG_GL_STATS_FCT_COUNT();
01166   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBeginOcclusionQueryNV );
01167   glContext()->m_glFunctions->glBeginOcclusionQueryNV( id );
01168   ASSERT_GL_NO_ERROR;
01169 }
01170
01172
01174 inline  void  GLBeginQuery( GLenum target, GLuint id )
01175 {
01176   NVSG_GL_STATS_FCT_COUNT();
01177   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBeginQueryARB );
01178   glContext()->m_glFunctions->glBeginQueryARB( target, id );
01179   ASSERT_GL_NO_ERROR;
01180 }
01181
01183
01185 inline  void  GLBindBuffer( GLenum target, GLuint id )
01186 {
01187   GLContext * ctx = glContext();
01188 #if defined( GL_CACHING )
01189   NVSG_ASSERT( ( target == GL_ARRAY_BUFFER_ARB ) || ( target == GL_ELEMENT_ARRAY_BUFFER_ARB ) );
01190   if ( ctx->m_vertexArrayAttributes.m_bufferBinding[target-GL_ARRAY_BUFFER_ARB] != id )
01191 #endif
01192   {
01193     NVSG_GL_STATS_BIND_BUFFER( target, id );
01194     NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glBindBufferARB );
01195     ctx->m_glFunctions->glBindBufferARB( target, id );
01196     ASSERT_GL_NO_ERROR;
01197 #if defined( GL_CACHING )
01198     ctx->m_vertexArrayAttributes.m_bufferBinding[target-GL_ARRAY_BUFFER_ARB] = id;
01199     if ( GL_ARRAY_BUFFER_ARB==target )
01200     {
01201       ctx->m_vertexArrayAttributes.m_vertexArrayParams.invalidate();
01202       ctx->m_vertexArrayAttributes.m_normalArrayParams.invalidate();
01203       ctx->m_vertexArrayAttributes.m_colorArrayParams.invalidate();
01204       ctx->m_vertexArrayAttributes.m_secondaryColorArrayParams.invalidate();
01205       ctx->m_vertexArrayAttributes.m_fogCoordArrayParams.invalidate();
01206       for ( size_t i=0 ; i<ctx->m_vertexArrayAttributes.m_textureCoordArrayParams.size() ; ++i )
01207       {
01208         ctx->m_vertexArrayAttributes.m_textureCoordArrayParams[i].invalidate();
01209       }
01210     }
01211 #endif
01212   }
01213 }
01214
01216
01218 inline  void  GLBufferData( GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage )
01219 {
01220   NVSG_GL_STATS_BUFFER_DATA( target, size, data, usage );
01221   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBufferDataARB );
01222   glContext()->m_glFunctions->glBufferDataARB( target, size, data, usage );
01223   ASSERT_GL_NO_ERROR;
01224 }
01225
01227
01229 inline  void  GLBufferSubData( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data )
01230 {
01231   NVSG_GL_STATS_FCT_COUNT();
01232   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBufferSubDataARB );
01233   glContext()->m_glFunctions->glBufferSubDataARB( target, offset, size, data );
01234   ASSERT_GL_NO_ERROR;
01235 }
01236
01238
01240 inline  void  GLDeleteBuffers(GLsizei n, const GLuint *buffers)
01241 {
01242   NVSG_GL_STATS_DELETE_BUFFERS( n, buffers );
01243   GLContext * ctx = glContext();
01244   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteBuffersARB );
01245 #if defined(GL_CACHING)
01246   for ( GLsizei i=0; i<n; ++i )
01247   {
01248     if (  ctx->m_vertexArrayAttributes.m_bufferBinding[0] == buffers[i] )
01249     {
01250       GLBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
01251     }
01252
01253     if (  ctx->m_vertexArrayAttributes.m_bufferBinding[1] == buffers[i] )
01254     {
01255       GLBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
01256     }
01257   }
01258   ctx->m_glObjects->removeBuffers(n, buffers);
01259 #endif
01260   ctx->m_glFunctions->glDeleteBuffersARB( n, buffers );
01261   ASSERT_GL_NO_ERROR;
01262 }
01263
01265
01266 inline  void  GLGenBuffers(GLsizei n, GLuint *buffers)
01267 {
01268   NVSG_GL_STATS_GEN_BUFFERS( n, buffers );
01269   GLContext * ctx = glContext();
01270   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenBuffersARB );
01271   ctx->m_glFunctions->glGenBuffersARB( n, buffers );
01272   ASSERT_GL_NO_ERROR;
01273 #if defined( GL_CACHING )
01274   ctx->m_glObjects->addBuffers(n, buffers);
01275 #endif
01276 }
01277
01279
01281 inline  GLvoid*  GLMapBuffer( GLenum target, GLenum access )
01282 {
01283   NVSG_GL_STATS_FCT_COUNT();
01284   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMapBufferARB );
01285   GLvoid * p = glContext()->m_glFunctions->glMapBufferARB( target, access );
01286   ASSERT_GL_NO_ERROR;
01287   return p;
01288 }
01289
01291
01293 inline  GLboolean  GLUnmapBuffer( GLenum target )
01294 {
01295   NVSG_GL_STATS_FCT_COUNT();
01296   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glUnmapBufferARB );
01297   GLboolean b = glContext()->m_glFunctions->glUnmapBufferARB( target );
01298   ASSERT_GL_NO_ERROR;
01299   return b;
01300 }
01301
01303
01304 inline  GLboolean  GLIsBuffer( GLuint name )
01305 {
01306   NVSG_GL_STATS_FCT_COUNT();
01307   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsBufferARB);
01308 #if defined( GL_CACHING )
01309   NVSG_ASSERT(!!glContext()->isVBO(name)==!!glContext()->m_glFunctions->glIsBufferARB(name));
01310   return glContext()->isVBO(name);
01311 #else
01312   return( glContext()->m_glFunctions->glIsBufferARB( name ) );
01313 #endif
01314 }
01315
01317
01319 inline  void  GLBindProgram( GLenum target, GLuint id )
01320 {
01321   NVSG_GL_STATS_FCT_COUNT();
01322   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBindProgramNV );
01323   glContext()->m_glFunctions->glBindProgramNV( target, id );
01324   ASSERT_GL_NO_ERROR;
01325 }
01326
01328
01329 inline  void  GLBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
01330 {
01331   NVSG_GL_STATS_FCT_COUNT();
01332   glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
01333   ASSERT_GL_NO_ERROR;
01334 }
01335
01337
01338 inline  void  GLBlendFunc( GLenum sfactor, GLenum dfactor )
01339 {
01340 #if defined(GL_CACHING)
01341   GLContext * ctx = glContext();
01342   if (    ( ctx->m_colorBufferAttributes.m_blendSrcRGB   != sfactor )
01343       ||  ( ctx->m_colorBufferAttributes.m_blendSrcAlpha != sfactor )
01344       ||  ( ctx->m_colorBufferAttributes.m_blendDstRGB   != dfactor )
01345       ||  ( ctx->m_colorBufferAttributes.m_blendDstAlpha != dfactor ) )
01346 #endif
01347   {
01348     NVSG_GL_STATS_BLEND_FUNC( sfactor, dfactor );
01349     glBlendFunc( sfactor, dfactor );
01350     ASSERT_GL_NO_ERROR;
01351 #if defined(GL_CACHING)
01352     ctx->m_colorBufferAttributes.m_blendSrcRGB   = sfactor;
01353     ctx->m_colorBufferAttributes.m_blendSrcAlpha = sfactor;
01354     ctx->m_colorBufferAttributes.m_blendDstRGB   = dfactor;
01355     ctx->m_colorBufferAttributes.m_blendDstAlpha = dfactor;
01356 #endif
01357   }
01358 }
01359
01361
01362 inline  void  GLBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
01363 {
01364   NVSG_ASSERT(GLIsExtensionAvailable("GL_EXT_blend_func_separate"));
01365 #if defined(GL_CACHING)
01366   GLContext * ctx = glContext();
01367   if (    ( ctx->m_colorBufferAttributes.m_blendSrcRGB   != sfactorRGB )
01368       ||  ( ctx->m_colorBufferAttributes.m_blendSrcAlpha != sfactorAlpha )
01369       ||  ( ctx->m_colorBufferAttributes.m_blendDstRGB   != dfactorRGB )
01370       ||  ( ctx->m_colorBufferAttributes.m_blendDstAlpha != dfactorAlpha ) )
01371 #endif
01372   {
01373     NVSG_GL_STATS_FCT_COUNT();
01374     NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glBlendFuncSeparate );
01375     glContext()->m_glFunctions->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
01376     ASSERT_GL_NO_ERROR;
01377 #if defined(GL_CACHING)
01378     ctx->m_colorBufferAttributes.m_blendSrcRGB   = sfactorRGB;
01379     ctx->m_colorBufferAttributes.m_blendSrcAlpha = sfactorAlpha;
01380     ctx->m_colorBufferAttributes.m_blendDstRGB   = dfactorRGB;
01381     ctx->m_colorBufferAttributes.m_blendDstAlpha = dfactorAlpha;
01382 #endif
01383   }
01384 }
01385
01387
01388 inline  void  GLBindTexture( GLenum target, GLuint texture )
01389 {
01390 #if defined( GL_CACHING )
01391   _GLUpdateActiveTexture();
01392 #endif
01393   NVSG_GL_STATS_BIND_TEXTURE( target, texture );
01394   glBindTexture( target, texture );
01395   ASSERT_GL_NO_ERROR;
01396 }
01397
01399
01400 inline  void  GLCallList( GLuint list )
01401 {
01402   NVSG_GL_STATS_CALL_LIST( list );
01403   glCallList( list );
01404   ASSERT_GL_NO_ERROR;
01405 }
01406
01408
01409 inline  void  GLCallLists( GLsizei n, GLenum type, const GLvoid *lists )
01410 {
01411   NVSG_GL_STATS_FCT_COUNT();
01412   glCallLists( n, type, lists );
01413   ASSERT_GL_NO_ERROR;
01414 }
01415
01417
01418 inline  void  GLClear( GLbitfield mask )
01419 {
01420   NVSG_GL_STATS_CLEAR( mask );
01421   glClear( mask );
01422   ASSERT_GL_NO_ERROR;
01423 }
01424
01426
01427 inline  void  GLClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
01428 {
01429   NVSG_GL_STATS_FCT_COUNT();
01430   glClearAccum( red, green, blue, alpha );
01431   ASSERT_GL_NO_ERROR;
01432 }
01433
01435
01436 inline  void  GLClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
01437 {
01438 #if defined( GL_CACHING )
01439   GLContext * ctx = glContext();
01440   if ( ! equal4f( red, green, blue, alpha, &ctx->m_colorBufferAttributes.m_clearColor[0] ) )
01441 #endif
01442   {
01443     NVSG_GL_STATS_CLEAR_COLOR( red, green, blue, alpha );
01444     glClearColor(red, green, blue, alpha);
01445     ASSERT_GL_NO_ERROR;
01446 #if defined( GL_CACHING )
01447     ctx->m_colorBufferAttributes.m_clearColor[0] = red;
01448     ctx->m_colorBufferAttributes.m_clearColor[1] = green;
01449     ctx->m_colorBufferAttributes.m_clearColor[2] = blue;
01450     ctx->m_colorBufferAttributes.m_clearColor[3] = alpha;
01451 #endif
01452   }
01453 }
01454
01456
01457 inline  void  GLClearDepth( GLclampd depth )
01458 {
01459   NVSG_GL_STATS_FCT_COUNT();
01460   glClearDepth( depth );
01461   ASSERT_GL_NO_ERROR;
01462 }
01463
01465
01466 inline  void  GLClearIndex( GLfloat c )
01467 {
01468   NVSG_GL_STATS_FCT_COUNT();
01469   glClearIndex( c );
01470   ASSERT_GL_NO_ERROR;
01471 }
01472
01474
01475 inline  void  GLClearStencil( GLint s )
01476 {
01477   NVSG_GL_STATS_FCT_COUNT();
01478   glClearStencil( s );
01479   ASSERT_GL_NO_ERROR;
01480 }
01481
01483
01484 inline  void  GLClientActiveTexture( GLenum texture )
01485 {
01486 #if defined( GL_CACHING )
01487   glContext()->m_vertexArrayAttributes.m_clientTextureToActivate = texture - GL_TEXTURE0;
01488 #else
01489   NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( texture );
01490   glContext()->m_glFunctions->glClientActiveTexture( texture );
01491   ASSERT_GL_NO_ERROR;
01492 #endif
01493 }
01494
01496
01497 inline  void  GLClipPlane( GLenum plane, const GLdouble *equation )
01498 {
01499   NVSG_GL_STATS_FCT_COUNT();
01500   glClipPlane(plane, equation);
01501   ASSERT_GL_NO_ERROR;
01502 }
01503
01505
01506 inline  void  GLColor3b( GLbyte red, GLbyte green, GLbyte blue )
01507 {
01508   NVSG_GL_STATS_COLOR3B( red, green, blue );
01509   glColor3b( red, green, blue );
01510   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01511 }
01512
01514
01515 inline  void  GLColor3bv( const GLbyte *v )
01516 {
01517   NVSG_GL_STATS_COLOR3BV( v );
01518   glColor3bv( v );
01519   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01520 }
01521
01523
01524 inline  void  GLColor3d( GLdouble red, GLdouble green, GLdouble blue )
01525 {
01526   NVSG_GL_STATS_COLOR3D( red, green, blue );
01527   glColor3d( red, green, blue );
01528   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01529 }
01530
01532
01533 inline  void  GLColor3dv( const GLdouble *v )
01534 {
01535   NVSG_GL_STATS_COLOR3DV( v );
01536   glColor3dv( v );
01537   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01538 }
01539
01541
01542 inline  void  GLColor3f( GLfloat red, GLfloat green, GLfloat blue )
01543 {
01544   NVSG_GL_STATS_COLOR3F( red, green, blue );
01545   glColor3f( red, green, blue );
01546   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01547 }
01548
01550
01551 inline  void  GLColor3fv( const GLfloat * v )
01552 {
01553   NVSG_GL_STATS_COLOR3FV( v );
01554   glColor3fv( v );
01555   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01556 }
01557
01559
01560 inline  void  GLColor3i( GLint red, GLint green, GLint blue )
01561 {
01562   NVSG_GL_STATS_COLOR3I( red, green, blue );
01563   glColor3i( red, green, blue );
01564   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01565 }
01566
01568
01569 inline  void  GLColor3iv( const GLint * v )
01570 {
01571   NVSG_GL_STATS_COLOR3IV( v );
01572   glColor3iv( v );
01573   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01574 }
01575
01577
01578 inline  void  GLColor3s( GLshort red, GLshort green, GLshort blue )
01579 {
01580   NVSG_GL_STATS_COLOR3S( red, green, blue );
01581   glColor3s( red, green, blue );
01582   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01583 }
01584
01586
01587 inline  void  GLColor3sv( const GLshort * v )
01588 {
01589   NVSG_GL_STATS_COLOR3SV( v );
01590   glColor3sv( v );
01591   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01592 }
01593
01595
01596 inline  void  GLColor3ub( GLubyte red, GLubyte green, GLubyte blue )
01597 {
01598   NVSG_GL_STATS_COLOR3UB( red, green, blue );
01599   glColor3ub( red, green, blue );
01600   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01601 }
01602
01604
01605 inline  void  GLColor3ubv( const GLubyte * v )
01606 {
01607   NVSG_GL_STATS_COLOR3UBV( v );
01608   glColor3ubv( v );
01609   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01610 }
01611
01613
01614 inline  void  GLColor3ui( GLuint red, GLuint green, GLuint blue )
01615 {
01616   NVSG_GL_STATS_COLOR3UI( red, green, blue );
01617   glColor3ui( red, green, blue );
01618   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01619 }
01620
01622
01623 inline  void  GLColor3uiv( const GLuint * v )
01624 {
01625   NVSG_GL_STATS_COLOR3UIV( v );
01626   glColor3uiv( v );
01627   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01628 }
01629
01631
01632 inline  void  GLColor3us( GLushort red, GLushort green, GLushort blue )
01633 {
01634   NVSG_GL_STATS_COLOR3US( red, green, blue );
01635   glColor3us( red, green, blue );
01636   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01637 }
01638
01640
01641 inline  void  GLColor3usv( const GLushort * v )
01642 {
01643   NVSG_GL_STATS_COLOR3USV( v );
01644   glColor3usv( v );
01645   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01646 }
01647
01649
01650 inline  void  GLColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
01651 {
01652   NVSG_GL_STATS_COLOR4B( red, green, blue, alpha );
01653   glColor4b( red, green, blue, alpha );
01654   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01655 }
01656
01658
01659 inline  void  GLColor4bv( const GLbyte * v )
01660 {
01661   NVSG_GL_STATS_COLOR4BV( v );
01662   glColor4bv( v );
01663   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01664 }
01665
01667
01668 inline  void  GLColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
01669 {
01670   NVSG_GL_STATS_COLOR4D( red, green, blue, alpha );
01671   glColor4d( red, green, blue, alpha );
01672   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01673 }
01674
01676
01677 inline  void  GLColor4dv( const GLdouble * v )
01678 {
01679   NVSG_GL_STATS_COLOR4DV( v );
01680   glColor4dv( v );
01681   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01682 }
01683
01685
01686 inline  void  GLColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
01687 {
01688   NVSG_GL_STATS_COLOR4F( red, green, blue, alpha );
01689   glColor4f( red, green, blue, alpha );
01690   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01691 }
01692
01694
01695 inline  void  GLColor4fv( const GLfloat * v )
01696 {
01697   NVSG_GL_STATS_COLOR4FV( v );
01698   glColor4fv( v );
01699   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01700 }
01701
01703
01704 inline  void  GLColor4i( GLint red, GLint green, GLint blue, GLint alpha )
01705 {
01706   NVSG_GL_STATS_COLOR4I( red, green, blue, alpha );
01707   glColor4i( red, green, blue, alpha );
01708   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01709 }
01710
01712
01713 inline  void  GLColor4iv( const GLint * v )
01714 {
01715   NVSG_GL_STATS_COLOR4IV( v );
01716   glColor4iv( v );
01717   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01718 }
01719
01721
01722 inline  void  GLColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
01723 {
01724   NVSG_GL_STATS_COLOR4S( red, green, blue, alpha );
01725   glColor4s( red, green, blue, alpha );
01726   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01727 }
01728
01730
01731 inline  void  GLColor4sv( const GLshort * v )
01732 {
01733   NVSG_GL_STATS_COLOR4SV( v );
01734   glColor4sv( v );
01735   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01736 }
01737
01739
01740 inline  void  GLColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
01741 {
01742   NVSG_GL_STATS_COLOR4UB( red, green, blue, alpha );
01743   glColor4ub( red, green, blue, alpha );
01744   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01745 }
01746
01748
01749 inline  void  GLColor4ubv( const GLubyte * v )
01750 {
01751   NVSG_GL_STATS_COLOR4UBV( v );
01752   glColor4ubv( v );
01753   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01754 }
01755
01757
01758 inline  void  GLColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
01759 {
01760   NVSG_GL_STATS_COLOR4UI( red, green, blue, alpha );
01761   glColor4ui( red, green, blue, alpha );
01762   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01763 }
01764
01766
01767 inline  void  GLColor4uiv( const GLuint * v )
01768 {
01769   NVSG_GL_STATS_COLOR4UIV( v );
01770   glColor4uiv( v );
01771   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01772 }
01773
01775
01776 inline  void  GLColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
01777 {
01778   NVSG_GL_STATS_COLOR4US( red, green, blue, alpha );
01779   glColor4us( red, green, blue, alpha );
01780   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01781 }
01782
01784
01785 inline  void  GLColor4usv( const GLushort * v )
01786 {
01787   NVSG_GL_STATS_COLOR4USV( v );
01788   glColor4usv( v );
01789   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
01790 }
01791
01793
01794 inline  void  GLColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
01795 {
01796   NVSG_GL_STATS_FCT_COUNT();
01797   glColorMask( red, green, blue, alpha );
01798   ASSERT_GL_NO_ERROR;
01799 }
01800
01802
01803 inline  void  GLColorMaterial( GLenum face, GLenum mode )
01804 {
01805   NVSG_GL_STATS_FCT_COUNT();
01806   glColorMaterial( face, mode );
01807   ASSERT_GL_NO_ERROR;
01808 }
01809
01811
01812 inline  void  GLColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
01813 {
01814 #if defined( GL_CACHING )
01815   GLContext * ctx = glContext();
01816   GLContext::VertexArrayParameters parameters( size, type, stride, pointer );
01817   if ( ctx->m_vertexArrayAttributes.m_colorArrayParams != parameters )
01818 #endif
01819   {
01820     NVSG_GL_STATS_FCT_COUNT();
01821     glColorPointer( size, type, stride, pointer );
01822     ASSERT_GL_NO_ERROR;
01823 #if defined( GL_CACHING )
01824     ctx->m_vertexArrayAttributes.m_colorArrayParams = parameters;
01825 #endif
01826   }
01827 }
01828
01830
01832 inline  void  GLCompressedTexImage1D( GLenum target, int level, GLenum internalformat, GLsizei width, int border, GLsizei imageSize, const void *data )
01833 {
01834 #if defined(GL_CACHING)
01835   _GLUpdateActiveTexture();
01836 #endif
01837   NVSG_GL_STATS_FCT_COUNT();
01838   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexImage1D );
01839   glContext()->m_glFunctions->glCompressedTexImage1D( target, level, internalformat, width, border, imageSize, data );
01840   ASSERT_GL_NO_ERROR;
01841 }
01842
01844
01846 inline  void  GLCompressedTexImage2D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, int border, GLsizei imageSize, const void *data )
01847 {
01848 #if defined(GL_CACHING)
01849   _GLUpdateActiveTexture();
01850 #endif
01851   NVSG_GL_STATS_FCT_COUNT();
01852   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexImage2D );
01853   glContext()->m_glFunctions->glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data );
01854   ASSERT_GL_NO_ERROR;
01855 }
01856
01858
01860 inline  void  GLCompressedTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLsizei imageSize, const void *data )
01861 {
01862 #if defined(GL_CACHING)
01863   _GLUpdateActiveTexture();
01864 #endif
01865   NVSG_GL_STATS_FCT_COUNT();
01866   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glCompressedTexImage3D );
01867   glContext()->m_glFunctions->glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data );
01868   ASSERT_GL_NO_ERROR;
01869 }
01870
01872
01873 inline  void  GLCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
01874 {
01875   NVSG_GL_STATS_FCT_COUNT();
01876   glCopyPixels( x, y, width, height, type );
01877   ASSERT_GL_NO_ERROR;
01878 }
01879
01881
01882 inline  void  GLCopyTexImage1D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border )
01883 {
01884 #if defined(GL_CACHING)
01885   _GLUpdateActiveTexture();
01886 #endif
01887   NVSG_GL_STATS_FCT_COUNT();
01888   glCopyTexImage1D( target, level, internalFormat, x, y, width, border );
01889   ASSERT_GL_NO_ERROR;
01890 }
01891
01893
01894 inline  void  GLCopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
01895 {
01896 #if defined(GL_CACHING)
01897   _GLUpdateActiveTexture();
01898 #endif
01899   NVSG_GL_STATS_FCT_COUNT();
01900   glCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
01901   ASSERT_GL_NO_ERROR;
01902 }
01903
01905
01906 inline  void  GLCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
01907 {
01908 #if defined(GL_CACHING)
01909   _GLUpdateActiveTexture();
01910 #endif
01911   NVSG_GL_STATS_FCT_COUNT();
01912   glCopyTexSubImage1D( target,level, xoffset, x, y, width );
01913   ASSERT_GL_NO_ERROR;
01914 }
01915
01917
01918 inline  void  GLCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
01919 {
01920 #if defined(GL_CACHING)
01921   _GLUpdateActiveTexture();
01922 #endif
01923   NVSG_GL_STATS_FCT_COUNT();
01924   glCopyTexSubImage2D( target,level, xoffset, yoffset, x, y, width, height );
01925   ASSERT_GL_NO_ERROR;
01926 }
01927
01929
01930 inline  void  GLCullFace( GLenum mode )
01931 {
01932   GLContext * ctx = glContext();
01933 #if defined( GL_CACHING )
01934   if ( ctx->m_polygonAttributes.m_cullFaceMode != mode )
01935 #endif
01936   {
01937     if ( ! ctx->m_locks.m_cullFaceMode )
01938     {
01939       NVSG_GL_STATS_FCT_COUNT();
01940       glCullFace( mode );
01941       ASSERT_GL_NO_ERROR;
01942 #if defined( GL_CACHING )
01943       ctx->m_polygonAttributes.m_cullFaceMode = mode;
01944 #endif
01945     }
01946   }
01947 }
01948
01949 inline void GLCullFaceLock( GLenum mode )
01950 {
01951   NVSG_ASSERT( ! glContext()->m_locks.m_cullFaceMode );
01952   GLCullFace( mode );
01953   glContext()->m_locks.m_cullFaceMode = true;
01954 }
01955
01956 inline void GLCullFaceUnlock( GLenum mode )
01957 {
01958   glContext()->m_locks.m_cullFaceMode = false;
01959   GLCullFace( mode );
01960 }
01961
01963
01964 inline  void  GLDeleteLists( GLuint list, GLsizei range )
01965 {
01966   NVSG_GL_STATS_DELETE_LISTS( list, range );
01967 #if defined( GL_CACHING )
01968   glContext()->m_glObjects->removeLists(range, list);
01969 #endif
01970   glDeleteLists( list, range );
01971   ASSERT_GL_NO_ERROR;
01972 }
01973
01975
01977 inline  void  GLDeleteOcclusionQueries( GLsizei n, const GLuint *ids )
01978 {
01979   NVSG_GL_STATS_FCT_COUNT();
01980   GLContext * ctx = glContext();
01981   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteOcclusionQueriesNV );
01982 #if defined( GL_CACHING )
01983   ctx->m_glObjects->removeOcclusionQueries(n, ids);
01984 #endif
01985   ctx->m_glFunctions->glDeleteOcclusionQueriesNV( n, ids );
01986   ASSERT_GL_NO_ERROR;
01987 }
01988
01990
01992 inline  void  GLDeletePrograms( GLsizei n, const GLuint *ids )
01993 {
01994   NVSG_GL_STATS_FCT_COUNT();
01995   GLContext * ctx = glContext();
01996   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteProgramsNV );
01997 #if defined( GL_CACHING )
01998   ctx->m_glObjects->removePrograms(n, ids);
01999 #endif
02000   ctx->m_glFunctions->glDeleteProgramsNV( n, ids );
02001   ASSERT_GL_NO_ERROR;
02002 }
02003
02005
02007 inline  void  GLDeleteQueries( GLsizei n, const GLuint *ids )
02008 {
02009   NVSG_GL_STATS_FCT_COUNT();
02010   GLContext * ctx = glContext();
02011   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glDeleteQueriesARB );
02012 #if defined( GL_CACHING )
02013   ctx->m_glObjects->removeQueries( n, ids );
02014 #endif
02015   ctx->m_glFunctions->glDeleteQueriesARB( n, ids );
02016   ASSERT_GL_NO_ERROR;
02017 }
02018
02020
02021 inline  void  GLDeleteTextures( GLsizei n, const GLuint *textures )
02022 {
02023   NVSG_GL_STATS_DELETE_TEXTURES( n, textures );
02024 #if defined( GL_CACHING )
02025   GLContext * ctx = glContext();
02026   ctx->m_glObjects->removeTextures(n, textures);
02027 #endif
02028   glDeleteTextures( n, textures );
02029   ASSERT_GL_NO_ERROR;
02030 }
02031
02033
02034 inline  void  GLDepthFunc( GLenum func )
02035 {
02036 #if defined( GL_CACHING )
02037   GLContext * ctx = glContext();
02038   if ( ctx->m_depthBufferAttributes.m_depthFunc != func )
02039   {
02040 #endif
02041     NVSG_GL_STATS_DEPTH_FUNC( func );
02042     glDepthFunc( func );
02043     ASSERT_GL_NO_ERROR;
02044 #if defined( GL_CACHING )
02045     ctx->m_depthBufferAttributes.m_depthFunc = func;
02046   }
02047 #endif
02048 }
02049
02051
02052 inline  void  GLDepthMask( GLboolean flag )
02053 {
02054 #if defined( GL_CACHING )
02055   GLContext * ctx = glContext();
02056   if ( ctx->m_depthBufferAttributes.m_depthWriting != flag )
02057   {
02058 #endif
02059     NVSG_GL_STATS_DEPTH_MASK( flag );
02060     glDepthMask( flag );
02061     ASSERT_GL_NO_ERROR;
02062 #if defined( GL_CACHING )
02063     ctx->m_depthBufferAttributes.m_depthWriting = flag;
02064   }
02065 #endif
02066 }
02067
02069
02070 inline  void  GLDepthRange( GLclampd znear, GLclampd zfar )
02071 {
02072   NVSG_GL_STATS_FCT_COUNT();
02073   glDepthRange( znear, zfar );
02074   ASSERT_GL_NO_ERROR;
02075 }
02076
02078
02080 inline  void  GLDisableBlend( void )
02081 {
02082 #if defined( GL_CACHING )
02083   GLContext * ctx = glContext();
02084   if ( ctx->m_colorBufferEnableAttributes.m_blend )
02085   {
02086     NVSG_ASSERT( glIsEnabled( GL_BLEND ) );
02087 #endif
02088     _GLDisable( GL_BLEND );
02089 #if defined( GL_CACHING )
02090     ctx->m_colorBufferEnableAttributes.m_blend = false;
02091   }
02092 #endif
02093 }
02094
02096
02098 inline  void  GLDisableColorMaterial( void )
02099 {
02100 #if defined( GL_CACHING )
02101   GLContext * ctx = glContext();
02102   if ( ctx->m_lightingAttributes.m_colorMaterial )
02103   {
02104     NVSG_ASSERT( glIsEnabled( GL_COLOR_MATERIAL ) );
02105 #endif
02106     _GLDisable( GL_COLOR_MATERIAL );
02107 #if defined( GL_CACHING )
02108     ctx->m_lightingAttributes.m_colorMaterial = false;
02109     glGetMaterialfv( GL_BACK, GL_AMBIENT, &ctx->m_lightingAttributes.m_materialAmbient[0][0] );
02110     glGetMaterialfv( GL_FRONT, GL_AMBIENT, &ctx->m_lightingAttributes.m_materialAmbient[1][0] );
02111     glGetMaterialfv( GL_BACK, GL_DIFFUSE, &ctx->m_lightingAttributes.m_materialDiffuse[0][0] );
02112     glGetMaterialfv( GL_FRONT, GL_DIFFUSE, &ctx->m_lightingAttributes.m_materialDiffuse[1][0] );
02113   }
02114 #endif
02115 }
02116
02118
02120 inline  void  GLDisableCullFace( void )
02121 {
02122   GLContext * ctx = glContext();
02123 #if defined( GL_CACHING )
02124   if ( ctx->m_polygonEnableAttributes.m_cullFace )
02125 #endif
02126   {
02127     if ( ! ctx->m_locks.m_cullFace )
02128     {
02129 #if defined( GL_CACHING )
02130       NVSG_ASSERT( glIsEnabled( GL_CULL_FACE ) );
02131 #endif
02132       _GLDisable( GL_CULL_FACE );
02133 #if defined( GL_CACHING )
02134       ctx->m_polygonEnableAttributes.m_cullFace = false;
02135 #endif
02136     }
02137   }
02138 }
02139
02140 inline void GLDisableCullFaceLock( void )
02141 {
02142   NVSG_ASSERT( ! glContext()->m_locks.m_cullFace );
02143   GLDisableCullFace();
02144   glContext()->m_locks.m_cullFace = true;
02145 }
02146
02147 inline void GLDisableCullFaceUnlock( void )
02148 {
02149   NVSG_ASSERT( glContext()->m_locks.m_cullFace );
02150   glContext()->m_locks.m_cullFace = false;
02151   GLDisableCullFace();
02152 }
02153
02155
02157 inline  void  GLDisableDepthTest( void )
02158 {
02159 #if defined( GL_CACHING )
02160   GLContext * ctx = glContext();
02161   if ( ctx->m_depthBufferEnableAttributes.m_depthTesting )
02162   {
02163     NVSG_ASSERT( glIsEnabled( GL_DEPTH_TEST ) );
02164 #endif
02165     _GLDisable( GL_DEPTH_TEST );
02166 #if defined( GL_CACHING )
02167     ctx->m_depthBufferEnableAttributes.m_depthTesting = false;
02168   }
02169 #endif
02170 }
02171
02173
02175 inline  void  GLDisableLighting( void )
02176 {
02177   GLContext * ctx = glContext();
02178 #if defined( GL_CACHING )
02179   if ( ctx->m_lightingEnableAttributes.m_lighting )
02180 #endif
02181   {
02182     if ( ! ctx->m_locks.m_lighting )
02183     {
02184 #if defined( GL_CACHING )
02185       NVSG_ASSERT( glIsEnabled( GL_LIGHTING ) );
02186 #endif
02187       _GLDisable( GL_LIGHTING );
02188 #if defined( GL_CACHING )
02189       ctx->m_lightingEnableAttributes.m_lighting = false;
02190 #endif
02191     }
02192   }
02193 }
02194
02195 inline void GLDisableLightingLock( void )
02196 {
02197   NVSG_ASSERT( ! glContext()->m_locks.m_lighting );
02198   GLDisableLighting();
02199   glContext()->m_locks.m_lighting = true;
02200 }
02201
02202 inline void GLDisableLightingUnlock( void )
02203 {
02204   NVSG_ASSERT( glContext()->m_locks.m_lighting );
02205   glContext()->m_locks.m_lighting = false;
02206   GLDisableLighting();
02207 }
02208
02210
02212 inline  void  GLDisableLineSmooth( void )
02213 {
02214 #if defined( GL_CACHING )
02215   GLContext * ctx = glContext();
02216   if ( ctx->m_lineEnableAttributes.m_smooth )
02217   {
02218     NVSG_ASSERT( glIsEnabled( GL_LINE_SMOOTH ) );
02219 #endif
02220     _GLDisable( GL_LINE_SMOOTH );
02221 #if defined( GL_CACHING )
02222     ctx->m_lineEnableAttributes.m_smooth = false;
02223   }
02224 #endif
02225 }
02226
02228
02230 inline  void  GLDisableLineStipple( void )
02231 {
02232 #if defined( GL_CACHING )
02233   GLContext * ctx = glContext();
02234   if ( ctx->m_lineEnableAttributes.m_stipple )
02235   {
02236     NVSG_ASSERT( glIsEnabled( GL_LINE_STIPPLE ) );
02237 #endif
02238     _GLDisable( GL_LINE_STIPPLE );
02239 #if defined( GL_CACHING )
02240     ctx->m_lineEnableAttributes.m_stipple = false;
02241   }
02242 #endif
02243 }
02244
02246
02248 inline  void  GLDisableNormalize( void )
02249 {
02250 #if defined( GL_CACHING )
02251   GLContext * ctx = glContext();
02252   if ( ctx->m_transformEnableAttributes.m_normalize )
02253   {
02254     NVSG_ASSERT( glIsEnabled( GL_NORMALIZE ) );
02255 #endif
02256     _GLDisable( GL_NORMALIZE );
02257 #if defined( GL_CACHING )
02258     ctx->m_transformEnableAttributes.m_normalize = false;
02259   }
02260 #endif
02261 }
02262
02264
02266 inline  void  GLDisablePointSmooth( void )
02267 {
02268 #if defined( GL_CACHING )
02269   GLContext * ctx = glContext();
02270   if ( ctx->m_pointEnableAttributes.m_smooth )
02271   {
02272     NVSG_ASSERT( glIsEnabled( GL_POINT_SMOOTH ) );
02273 #endif
02274     _GLDisable( GL_POINT_SMOOTH );
02275 #if defined( GL_CACHING )
02276     ctx->m_pointEnableAttributes.m_smooth = false;
02277   }
02278 #endif
02279 }
02280
02282
02284 inline  void  GLDisablePolygonOffsetFill( void )
02285 {
02286 #if defined( GL_CACHING )
02287   GLContext * ctx = glContext();
02288   if ( ctx->m_polygonEnableAttributes.m_offsetFill )
02289   {
02290     NVSG_ASSERT( glIsEnabled( GL_POLYGON_OFFSET_FILL ) );
02291 #endif
02292     _GLDisable( GL_POLYGON_OFFSET_FILL );
02293 #if defined( GL_CACHING )
02294     ctx->m_polygonEnableAttributes.m_offsetFill = false;
02295   }
02296 #endif
02297 }
02298
02300
02302 inline  void  GLDisablePolygonOffsetLine( void )
02303 {
02304 #if defined( GL_CACHING )
02305   GLContext * ctx = glContext();
02306   if ( ctx->m_polygonEnableAttributes.m_offsetLine )
02307   {
02308     NVSG_ASSERT( glIsEnabled( GL_POLYGON_OFFSET_LINE ) );
02309 #endif
02310     _GLDisable( GL_POLYGON_OFFSET_LINE );
02311 #if defined( GL_CACHING )
02312     ctx->m_polygonEnableAttributes.m_offsetLine = false;
02313   }
02314 #endif
02315 }
02316
02318
02320 inline  void  GLDisablePolygonOffsetPoint( void )
02321 {
02322 #if defined( GL_CACHING )
02323   GLContext * ctx = glContext();
02324   if ( ctx->m_polygonEnableAttributes.m_offsetPoint )
02325   {
02326     NVSG_ASSERT( glIsEnabled( GL_POLYGON_OFFSET_POINT ) );
02327 #endif
02328     _GLDisable( GL_POLYGON_OFFSET_POINT );
02329 #if defined( GL_CACHING )
02330     ctx->m_polygonEnableAttributes.m_offsetPoint = false;
02331   }
02332 #endif
02333 }
02334
02336
02338 inline  void  GLDisablePolygonStipple( void )
02339 {
02340 #if defined( GL_CACHING )
02341   GLContext * ctx = glContext();
02342   if ( ctx->m_polygonEnableAttributes.m_stipple )
02343   {
02344     NVSG_ASSERT( glIsEnabled( GL_POLYGON_STIPPLE ) );
02345 #endif
02346     _GLDisable( GL_POLYGON_STIPPLE );
02347 #if defined( GL_CACHING )
02348     ctx->m_polygonEnableAttributes.m_stipple = false;
02349   }
02350 #endif
02351 }
02352
02354
02356 inline void GLDisableTexture( GLenum target )
02357 {
02358 #if defined( GL_CACHING )
02359   GLContext * ctx = glContext();
02360   NVSG_ASSERT(   ( target == GL_TEXTURE_1D ) || ( target == GL_TEXTURE_2D ) || ( target == GL_TEXTURE_3D )
02361              ||  ( target == GL_TEXTURE_CUBE_MAP ) || ( target == GL_TEXTURE_RECTANGLE_NV ) );
02362   if ( ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_texture[target] )
02363   {
02364     _GLUpdateActiveTexture();
02365     NVSG_ASSERT( glIsEnabled( target ) );
02366 #endif
02367     _GLDisable( target );
02368 #if defined( GL_CACHING )
02369     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_texture[target] = false;
02370   }
02371 #endif
02372 }
02373
02375
02377 inline void GLDisableTextureGen( GLenum target )
02378 {
02379 #if defined( GL_CACHING )
02380   GLContext * ctx = glContext();
02381   NVSG_ASSERT(    ( target == GL_TEXTURE_GEN_S )
02382               ||  ( target == GL_TEXTURE_GEN_T )
02383               ||  ( target == GL_TEXTURE_GEN_R )
02384               ||  ( target == GL_TEXTURE_GEN_Q ) );
02385   if ( ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_gen[target-GL_TEXTURE_GEN_S] )
02386   {
02387     _GLUpdateActiveTexture();
02388     NVSG_ASSERT( glIsEnabled( target ) );
02389 #endif
02390     _GLDisable( target );
02391 #if defined( GL_CACHING )
02392     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_gen[target-GL_TEXTURE_GEN_S] = false;
02393   }
02394 #endif
02395 }
02396
02398
02399 inline  void  GLDisable( GLenum cap )
02400 {
02401 #if defined( GL_CACHING )
02402   switch( cap )
02403   {
02404     case GL_BLEND :
02405       GLDisableBlend();
02406       break;
02407     case GL_COLOR_MATERIAL :
02408       GLDisableColorMaterial();
02409       break;
02410     case GL_CULL_FACE :
02411       GLDisableCullFace();
02412       break;
02413     case GL_DEPTH_TEST :
02414       GLDisableDepthTest();
02415       break;
02416     case GL_LIGHTING :
02417       GLDisableLighting();
02418       break;
02419     case GL_LINE_SMOOTH :
02420       GLDisableLineSmooth();
02421       break;
02422     case GL_LINE_STIPPLE :
02423       GLDisableLineStipple();
02424       break;
02425     case GL_NORMALIZE :
02426       GLDisableNormalize();
02427       break;
02428     case GL_POINT_SMOOTH :
02429       GLDisablePointSmooth();
02430       break;
02431     case GL_POLYGON_OFFSET_FILL :
02432       GLDisablePolygonOffsetFill();
02433       break;
02434     case GL_POLYGON_OFFSET_LINE :
02435       GLDisablePolygonOffsetLine();
02436       break;
02437     case GL_POLYGON_OFFSET_POINT :
02438       GLDisablePolygonOffsetPoint();
02439       break;
02440     case GL_POLYGON_STIPPLE :
02441       GLDisablePolygonStipple();
02442       break;
02443     case GL_TEXTURE_1D :
02444     case GL_TEXTURE_2D :
02445     case GL_TEXTURE_3D :
02446     case GL_TEXTURE_CUBE_MAP :
02447     case GL_TEXTURE_RECTANGLE_NV :
02448       GLDisableTexture( cap );
02449       break;
02450     case GL_TEXTURE_GEN_S :
02451     case GL_TEXTURE_GEN_T :
02452     case GL_TEXTURE_GEN_R :
02453     case GL_TEXTURE_GEN_Q :
02454       GLDisableTextureGen( cap );
02455       break;
02456     default :
02457       _GLDisable( cap );
02458       break;
02459   }
02460 #else
02461   switch( cap )
02462   {
02463     case GL_CULL_FACE :
02464       GLDisableCullFace();
02465       break;
02466     default :
02467       _GLEnable( cap );
02468       break;
02469   }
02470 #endif
02471 }
02472
02474
02476 inline  void  GLDisableColorArray( void )
02477 {
02478 #if defined( GL_CACHING )
02479   GLContext * ctx = glContext();
02480   if ( ctx->m_vertexArrayAttributes.m_colorArray )
02481   {
02482     NVSG_ASSERT( glIsEnabled( GL_COLOR_ARRAY ) );
02483 #endif
02484     _GLDisableClientState( GL_COLOR_ARRAY );
02485 #if defined( GL_CACHING )
02486     ctx->m_vertexArrayAttributes.m_colorArray = false;
02487   }
02488 #endif
02489 }
02490
02492
02494 inline  void  GLDisableFogCoordinateArray( void )
02495 {
02496 #if defined( GL_CACHING )
02497   GLContext * ctx = glContext();
02498   if ( ctx->m_vertexArrayAttributes.m_fogCoordArray )
02499   {
02500     NVSG_ASSERT( glIsEnabled( GL_FOG_COORDINATE_ARRAY ) );
02501 #endif
02502     _GLDisableClientState( GL_FOG_COORDINATE_ARRAY );
02503 #if defined( GL_CACHING )
02504     ctx->m_vertexArrayAttributes.m_fogCoordArray = false;
02505   }
02506 #endif
02507 }
02508
02510
02512 inline  void  GLDisableNormalArray( void )
02513 {
02514 #if defined( GL_CACHING )
02515   GLContext * ctx = glContext();
02516   if ( ctx->m_vertexArrayAttributes.m_normalArray )
02517   {
02518     NVSG_ASSERT( glIsEnabled( GL_NORMAL_ARRAY ) );
02519 #endif
02520     _GLDisableClientState( GL_NORMAL_ARRAY );
02521 #if defined( GL_CACHING )
02522     ctx->m_vertexArrayAttributes.m_normalArray = false;
02523   }
02524 #endif
02525 }
02526
02528
02530 inline  void  GLDisableSecondaryColorArray( void )
02531 {
02532 #if defined( GL_CACHING )
02533   GLContext * ctx = glContext();
02534   if ( ctx->m_vertexArrayAttributes.m_secondaryColorArray )
02535   {
02536     NVSG_ASSERT( glIsEnabled( GL_SECONDARY_COLOR_ARRAY ) );
02537 #endif
02538     _GLDisableClientState( GL_SECONDARY_COLOR_ARRAY );
02539 #if defined( GL_CACHING )
02540     ctx->m_vertexArrayAttributes.m_secondaryColorArray = false;
02541   }
02542 #endif
02543 }
02544
02546
02548 inline  void  GLDisableTextureCoordArray( void )
02549 {
02550 #if defined( GL_CACHING )
02551   GLContext * ctx = glContext();
02552   if ( ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureToActivate] )
02553   {
02554     _GLUpdateClientActiveTexture();
02555     NVSG_ASSERT( glIsEnabled( GL_TEXTURE_COORD_ARRAY ) );
02556 #endif
02557     _GLDisableClientState( GL_TEXTURE_COORD_ARRAY );
02558 #if defined( GL_CACHING )
02559     ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureActive] = false;
02560   }
02561 #endif
02562 }
02563
02565
02567 inline  void  GLDisableVertexArray( void )
02568 {
02569 #if defined( GL_CACHING )
02570   GLContext * ctx = glContext();
02571   if ( ctx->m_vertexArrayAttributes.m_vertexArray )
02572   {
02573     NVSG_ASSERT( glIsEnabled( GL_VERTEX_ARRAY ) );
02574 #endif
02575     _GLDisableClientState( GL_VERTEX_ARRAY );
02576 #if defined( GL_CACHING )
02577     ctx->m_vertexArrayAttributes.m_vertexArray = false;
02578   }
02579 #endif
02580 }
02581
02583
02584 inline  void  GLDisableClientState( GLenum array )
02585 {
02586 #if defined( GL_CACHING )
02587   switch( array )
02588   {
02589     case GL_COLOR_ARRAY :
02590       GLDisableColorArray();
02591       break;
02592     case GL_FOG_COORDINATE_ARRAY :
02593       GLDisableFogCoordinateArray();
02594       break;
02595     case GL_NORMAL_ARRAY :
02596       GLDisableNormalArray();
02597       break;
02598     case GL_SECONDARY_COLOR_ARRAY :
02599       GLDisableSecondaryColorArray();
02600       break;
02601     case GL_TEXTURE_COORD_ARRAY :
02602       GLDisableTextureCoordArray();
02603       break;
02604     case GL_VERTEX_ARRAY :
02605       GLDisableVertexArray();
02606       break;
02607     default :
02608       _GLDisableClientState( array );
02609       break;
02610   }
02611 #else
02612   _GLDisableClientState( array );
02613 #endif
02614 }
02615
02617
02618 inline  void  GLDrawArrays( GLenum mode, GLint first, GLsizei count )
02619 {
02620   NVSG_GL_STATS_FCT_COUNT();
02621   glDrawArrays( mode, first, count );
02622   ASSERT_GL_NO_ERROR;
02623 }
02624
02626
02627 inline  void  GLDrawBuffer( GLenum mode )
02628 {
02629   NVSG_GL_STATS_FCT_COUNT();
02630   glDrawBuffer( mode );
02631   ASSERT_GL_NO_ERROR;
02632 }
02633
02635
02636 inline  void  GLDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
02637 {
02638   NVSG_GL_STATS_DRAW_ELEMENTS( mode, count, type, indices );
02639   ASSERT_GL_ARRAY_BUFFER_BINDING();
02640   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
02641   glDrawElements( mode, count, type, indices );
02642   ASSERT_GL_NO_ERROR;
02643 }
02644
02646
02647 inline  void  GLMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount )
02648 {
02649   NVSG_GL_STATS_FCT_COUNT();
02650   ASSERT_GL_ARRAY_BUFFER_BINDING();
02651   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
02652   glContext()->m_glFunctions->glMultiDrawElements( mode, count, type, indices, primcount );
02653   ASSERT_GL_NO_ERROR;
02654 }
02655
02657
02658 inline  void  GLDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
02659 {
02660   NVSG_GL_STATS_FCT_COUNT();
02661   glDrawPixels( width, height, format, type, pixels );
02662   ASSERT_GL_NO_ERROR;
02663 }
02664
02666
02667 inline  void  GLDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices )
02668 {
02669   NVSG_GL_STATS_DRAW_RANGE_ELEMENTS( mode, start, end, count, type, indices );
02670   ASSERT_GL_ARRAY_BUFFER_BINDING();
02671   ASSERT_GL_ELEMENT_ARRAY_BUFFER_BINDING();
02672   glContext()->m_glFunctions->glDrawRangeElements( mode, start, end, count, type, indices );
02673   ASSERT_GL_NO_ERROR;
02674 }
02675
02677
02678 inline  void  GLEdgeFlagPointer( GLsizei stride, const GLboolean *pointer )
02679 {
02680   NVSG_GL_STATS_FCT_COUNT();
02681   glEdgeFlagPointer( stride, pointer );
02682   ASSERT_GL_NO_ERROR;
02683 }
02684
02686
02687 inline  void  GLEdgeFlag( GLboolean flag )
02688 {
02689   NVSG_GL_STATS_FCT_COUNT();
02690   glEdgeFlag( flag );
02691   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
02692 }
02693
02695
02696 inline  void  GLEdgeFlagv( const GLboolean *flag )
02697 {
02698   NVSG_GL_STATS_FCT_COUNT();
02699   glEdgeFlagv( flag );
02700   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
02701 }
02702
02704
02706 inline  void  GLEnableBlend( void )
02707 {
02708 #if defined( GL_CACHING )
02709   GLContext * ctx = glContext();
02710   if ( ! ctx->m_colorBufferEnableAttributes.m_blend )
02711   {
02712     NVSG_ASSERT( ! glIsEnabled( GL_BLEND ) );
02713 #endif
02714     _GLEnable( GL_BLEND );
02715 #if defined( GL_CACHING )
02716     ctx->m_colorBufferEnableAttributes.m_blend = true;
02717   }
02718 #endif
02719 }
02720
02722
02724 inline  void  GLEnableColorMaterial( void )
02725 {
02726 #if defined( GL_CACHING )
02727   GLContext * ctx = glContext();
02728   if ( ! ctx->m_lightingAttributes.m_colorMaterial )
02729   {
02730     NVSG_ASSERT( ! glIsEnabled( GL_COLOR_MATERIAL ) );
02731 #endif
02732     _GLEnable( GL_COLOR_MATERIAL );
02733 #if defined( GL_CACHING )
02734     ctx->m_lightingAttributes.m_colorMaterial = true;
02735   }
02736 #endif
02737 }
02738
02740
02742 inline  void  GLEnableCullFace( void )
02743 {
02744   GLContext * ctx = glContext();
02745 #if defined( GL_CACHING )
02746   if ( ! ctx->m_polygonEnableAttributes.m_cullFace )
02747 #endif
02748   {
02749     if ( ! ctx->m_locks.m_cullFace )
02750     {
02751 #if defined( GL_CACHING )
02752       NVSG_ASSERT( ! glIsEnabled( GL_CULL_FACE ) );
02753 #endif
02754       _GLEnable( GL_CULL_FACE );
02755 #if defined( GL_CACHING )
02756       ctx->m_polygonEnableAttributes.m_cullFace = true;
02757 #endif
02758     }
02759   }
02760 }
02761
02762 inline void GLEnableCullFaceLock( void )
02763 {
02764   NVSG_ASSERT( ! glContext()->m_locks.m_cullFace );
02765   GLEnableCullFace();
02766   glContext()->m_locks.m_cullFace = true;
02767 }
02768
02769 inline void GLEnableCullFaceUnlock( void )
02770 {
02771   NVSG_ASSERT( glContext()->m_locks.m_cullFace );
02772   glContext()->m_locks.m_cullFace = false;
02773   GLEnableCullFace();
02774 }
02775
02777
02779 inline  void  GLEnableDepthTest( void )
02780 {
02781 #if defined( GL_CACHING )
02782   GLContext * ctx = glContext();
02783   if ( ! ctx->m_depthBufferEnableAttributes.m_depthTesting )
02784   {
02785     NVSG_ASSERT( ! glIsEnabled( GL_DEPTH_TEST ) );
02786 #endif
02787     _GLEnable( GL_DEPTH_TEST );
02788 #if defined( GL_CACHING )
02789     ctx->m_depthBufferEnableAttributes.m_depthTesting = true;
02790   }
02791 #endif
02792 }
02793
02795
02797 inline  void  GLEnableLighting( void )
02798 {
02799   GLContext * ctx = glContext();
02800 #if defined( GL_CACHING )
02801   if ( ! ctx->m_lightingEnableAttributes.m_lighting )
02802 #endif
02803   {
02804     if ( ! ctx->m_locks.m_lighting )
02805     {
02806 #if defined( GL_CACHING )
02807       NVSG_ASSERT( ! glIsEnabled( GL_LIGHTING ) );
02808 #endif
02809       _GLEnable( GL_LIGHTING );
02810 #if defined( GL_CACHING )
02811       ctx->m_lightingEnableAttributes.m_lighting = true;
02812 #endif
02813     }
02814   }
02815 }
02816
02818
02820 inline  void  GLEnableLineSmooth( void )
02821 {
02822 #if defined( GL_CACHING )
02823   GLContext * ctx = glContext();
02824   if ( ! ctx->m_lineEnableAttributes.m_smooth )
02825   {
02826     NVSG_ASSERT( ! glIsEnabled( GL_LINE_SMOOTH ) );
02827 #endif
02828     _GLEnable( GL_LINE_SMOOTH );
02829 #if defined( GL_CACHING )
02830     ctx->m_lineEnableAttributes.m_smooth = true;
02831   }
02832 #endif
02833 }
02834
02836
02838 inline  void  GLEnableLineStipple( void )
02839 {
02840 #if defined( GL_CACHING )
02841   GLContext * ctx = glContext();
02842   if ( ! ctx->m_lineEnableAttributes.m_stipple )
02843   {
02844     NVSG_ASSERT( ! glIsEnabled( GL_LINE_STIPPLE ) );
02845 #endif
02846     _GLEnable( GL_LINE_STIPPLE );
02847 #if defined( GL_CACHING )
02848     ctx->m_lineEnableAttributes.m_stipple = true;
02849   }
02850 #endif
02851 }
02852
02854
02856 inline  void  GLEnableNormalize( void )
02857 {
02858 #if defined( GL_CACHING )
02859   GLContext * ctx = glContext();
02860   if ( ! ctx->m_transformEnableAttributes.m_normalize )
02861   {
02862     NVSG_ASSERT( ! glIsEnabled( GL_NORMALIZE ) );
02863 #endif
02864     _GLEnable( GL_NORMALIZE );
02865 #if defined( GL_CACHING )
02866     ctx->m_transformEnableAttributes.m_normalize = true;
02867   }
02868 #endif
02869 }
02870
02872
02874 inline  void  GLEnablePointSmooth( void )
02875 {
02876 #if defined( GL_CACHING )
02877   GLContext * ctx = glContext();
02878   if ( ! ctx->m_pointEnableAttributes.m_smooth )
02879   {
02880     NVSG_ASSERT( ! glIsEnabled( GL_POINT_SMOOTH ) );
02881 #endif
02882     _GLEnable( GL_POINT_SMOOTH );
02883 #if defined( GL_CACHING )
02884     ctx->m_pointEnableAttributes.m_smooth = true;
02885   }
02886 #endif
02887 }
02888
02890
02892 inline  void  GLEnablePolygonOffsetFill( void )
02893 {
02894 #if defined( GL_CACHING )
02895   GLContext * ctx = glContext();
02896   if ( ! ctx->m_polygonEnableAttributes.m_offsetFill )
02897   {
02898     NVSG_ASSERT( ! glIsEnabled( GL_POLYGON_OFFSET_FILL ) );
02899 #endif
02900     _GLEnable( GL_POLYGON_OFFSET_FILL );
02901 #if defined( GL_CACHING )
02902     ctx->m_polygonEnableAttributes.m_offsetFill = true;
02903   }
02904 #endif
02905 }
02906
02908
02910 inline  void  GLEnablePolygonOffsetLine( void )
02911 {
02912 #if defined( GL_CACHING )
02913   GLContext * ctx = glContext();
02914   if ( ! ctx->m_polygonEnableAttributes.m_offsetLine )
02915   {
02916     NVSG_ASSERT( ! glIsEnabled( GL_POLYGON_OFFSET_LINE ) );
02917 #endif
02918     _GLEnable( GL_POLYGON_OFFSET_LINE );
02919 #if defined( GL_CACHING )
02920     ctx->m_polygonEnableAttributes.m_offsetLine = true;
02921   }
02922 #endif
02923 }
02924
02926
02928 inline  void  GLEnablePolygonOffsetPoint( void )
02929 {
02930 #if defined( GL_CACHING )
02931   GLContext * ctx = glContext();
02932   if ( ! ctx->m_polygonEnableAttributes.m_offsetPoint )
02933   {
02934     NVSG_ASSERT( ! glIsEnabled( GL_POLYGON_OFFSET_POINT ) );
02935 #endif
02936     _GLEnable( GL_POLYGON_OFFSET_POINT );
02937 #if defined( GL_CACHING )
02938     ctx->m_polygonEnableAttributes.m_offsetPoint = true;
02939   }
02940 #endif
02941 }
02942
02944
02946 inline  void  GLEnablePolygonStipple( void )
02947 {
02948 #if defined( GL_CACHING )
02949   GLContext * ctx = glContext();
02950   if ( ! ctx->m_polygonEnableAttributes.m_stipple )
02951   {
02952     NVSG_ASSERT( ! glIsEnabled( GL_POLYGON_STIPPLE ) );
02953 #endif
02954     _GLEnable( GL_POLYGON_STIPPLE );
02955 #if defined( GL_CACHING )
02956     ctx->m_polygonEnableAttributes.m_stipple = true;
02957   }
02958 #endif
02959 }
02960
02962
02964 inline void GLEnableTexture( GLenum target )
02965 {
02966 #if defined( GL_CACHING )
02967   GLContext * ctx = glContext();
02968   NVSG_ASSERT(   ( target == GL_TEXTURE_1D ) || ( target == GL_TEXTURE_2D ) || ( target == GL_TEXTURE_3D )
02969              ||  ( target == GL_TEXTURE_CUBE_MAP ) || ( target == GL_TEXTURE_RECTANGLE_NV ) );
02970   if ( !ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_texture[target] )
02971   {
02972     _GLUpdateActiveTexture();
02973     NVSG_ASSERT( ! glIsEnabled( target ) );
02974 #endif
02975     _GLEnable( target );
02976 #if defined( GL_CACHING )
02977     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_texture[target] = true;
02978   }
02979 #endif
02980 }
02981
02983
02985 inline void GLEnableTextureGen( GLenum target )
02986 {
02987 #if defined( GL_CACHING )
02988   GLContext * ctx = glContext();
02989   NVSG_ASSERT(    ( target == GL_TEXTURE_GEN_S )
02990               ||  ( target == GL_TEXTURE_GEN_T )
02991               ||  ( target == GL_TEXTURE_GEN_R )
02992               ||  ( target == GL_TEXTURE_GEN_Q ) );
02993   if ( ! ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_toActivate].m_gen[target-GL_TEXTURE_GEN_S] )
02994   {
02995     _GLUpdateActiveTexture();
02996     NVSG_ASSERT( ! glIsEnabled( target ) );
02997 #endif
02998     _GLEnable( target );
02999 #if defined( GL_CACHING )
03000     ctx->m_textureEnableAttributes.m_unit[ctx->m_textureAttributes.m_active].m_gen[target-GL_TEXTURE_GEN_S] = true;
03001   }
03002 #endif
03003 }
03004
03006
03007 inline  void  GLEnable( GLenum cap )
03008 {
03009 #if defined( GL_CACHING )
03010   switch( cap )
03011   {
03012     case GL_BLEND :
03013       GLEnableBlend();
03014       break;
03015     case GL_COLOR_MATERIAL :
03016       GLEnableColorMaterial();
03017       break;
03018     case GL_CULL_FACE :
03019       GLEnableCullFace();
03020       break;
03021     case GL_DEPTH_TEST :
03022       GLEnableDepthTest();
03023       break;
03024     case GL_LIGHTING :
03025       GLEnableLighting();
03026       break;
03027     case GL_LINE_SMOOTH :
03028       GLEnableLineSmooth();
03029       break;
03030     case GL_LINE_STIPPLE :
03031       GLEnableLineStipple();
03032       break;
03033     case GL_NORMALIZE :
03034       GLEnableNormalize();
03035       break;
03036     case GL_POINT_SMOOTH :
03037       GLEnablePointSmooth();
03038       break;
03039     case GL_POLYGON_OFFSET_FILL :
03040       GLEnablePolygonOffsetFill();
03041       break;
03042     case GL_POLYGON_OFFSET_LINE :
03043       GLEnablePolygonOffsetLine();
03044       break;
03045     case GL_POLYGON_OFFSET_POINT :
03046       GLEnablePolygonOffsetPoint();
03047       break;
03048     case GL_POLYGON_STIPPLE :
03049       GLEnablePolygonStipple();
03050       break;
03051     case GL_TEXTURE_1D :
03052     case GL_TEXTURE_2D :
03053     case GL_TEXTURE_3D :
03054     case GL_TEXTURE_CUBE_MAP :
03055     case GL_TEXTURE_RECTANGLE_NV :
03056       GLEnableTexture( cap );
03057       break;
03058     case GL_TEXTURE_GEN_S :
03059     case GL_TEXTURE_GEN_T :
03060     case GL_TEXTURE_GEN_R :
03061     case GL_TEXTURE_GEN_Q :
03062       GLEnableTextureGen( cap );
03063       break;
03064     default :
03065       _GLEnable( cap );
03066       break;
03067   }
03068 #else
03069   switch( cap )
03070   {
03071     case GL_CULL_FACE :
03072       GLEnableCullFace();
03073       break;
03074     default :
03075       _GLEnable( cap );
03076       break;
03077   }
03078 #endif
03079 }
03080
03082
03084 inline  void  GLEnableColorArray( void )
03085 {
03086 #if defined( GL_CACHING )
03087   GLContext * ctx = glContext();
03088   if ( ! ctx->m_vertexArrayAttributes.m_colorArray )
03089   {
03090     NVSG_ASSERT( ! glIsEnabled( GL_COLOR_ARRAY ) );
03091 #endif
03092     _GLEnableClientState( GL_COLOR_ARRAY );
03093 #if defined( GL_CACHING )
03094     ctx->m_vertexArrayAttributes.m_colorArray = true;
03095   }
03096 #endif
03097 }
03098
03100
03102 inline  void  GLEnableFogCoordinateArray( void )
03103 {
03104 #if defined( GL_CACHING )
03105   GLContext * ctx = glContext();
03106   if ( ! ctx->m_vertexArrayAttributes.m_fogCoordArray )
03107   {
03108     NVSG_ASSERT( ! glIsEnabled( GL_FOG_COORDINATE_ARRAY ) );
03109 #endif
03110     _GLEnableClientState( GL_FOG_COORDINATE_ARRAY );
03111 #if defined( GL_CACHING )
03112     ctx->m_vertexArrayAttributes.m_fogCoordArray = true;
03113   }
03114 #endif
03115 }
03116
03118
03120 inline  void  GLEnableNormalArray( void )
03121 {
03122 #if defined( GL_CACHING )
03123   GLContext * ctx = glContext();
03124   if ( ! ctx->m_vertexArrayAttributes.m_normalArray )
03125   {
03126     NVSG_ASSERT( ! glIsEnabled( GL_NORMAL_ARRAY ) );
03127 #endif
03128     _GLEnableClientState( GL_NORMAL_ARRAY );
03129 #if defined( GL_CACHING )
03130     ctx->m_vertexArrayAttributes.m_normalArray = true;
03131   }
03132 #endif
03133 }
03134
03136
03138 inline  void  GLEnableSecondaryColorArray( void )
03139 {
03140 #if defined( GL_CACHING )
03141   GLContext * ctx = glContext();
03142   if ( ! ctx->m_vertexArrayAttributes.m_secondaryColorArray )
03143   {
03144     NVSG_ASSERT( ! glIsEnabled( GL_SECONDARY_COLOR_ARRAY ) );
03145 #endif
03146     _GLEnableClientState( GL_SECONDARY_COLOR_ARRAY );
03147 #if defined( GL_CACHING )
03148     ctx->m_vertexArrayAttributes.m_secondaryColorArray = true;
03149   }
03150 #endif
03151 }
03152
03154
03156 inline  void  GLEnableTextureCoordArray( void )
03157 {
03158 #if defined( GL_CACHING )
03159   GLContext * ctx = glContext();
03160   if ( ! ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureToActivate] )
03161   {
03162     _GLUpdateClientActiveTexture();
03163     NVSG_ASSERT( ! glIsEnabled( GL_TEXTURE_COORD_ARRAY ) );
03164 #endif
03165     _GLEnableClientState( GL_TEXTURE_COORD_ARRAY );
03166 #if defined( GL_CACHING )
03167     ctx->m_vertexArrayAttributes.m_textureCoordArray[ctx->m_vertexArrayAttributes.m_clientTextureActive] = true;
03168   }
03169 #endif
03170 }
03171
03173
03175 inline  void  GLEnableVertexArray( void )
03176 {
03177 #if defined( GL_CACHING )
03178   GLContext * ctx = glContext();
03179   if ( ! ctx->m_vertexArrayAttributes.m_vertexArray )
03180   {
03181     NVSG_ASSERT( ! glIsEnabled( GL_VERTEX_ARRAY ) );
03182 #endif
03183     _GLEnableClientState( GL_VERTEX_ARRAY );
03184 #if defined( GL_CACHING )
03185     ctx->m_vertexArrayAttributes.m_vertexArray = true;
03186   }
03187 #endif
03188 }
03189
03191
03192 inline  void  GLEnableClientState( GLenum array )
03193 {
03194 #if defined( GL_CACHING )
03195   switch( array )
03196   {
03197     case GL_COLOR_ARRAY :
03198       GLEnableColorArray();
03199       break;
03200     case GL_FOG_COORDINATE_ARRAY :
03201       GLEnableFogCoordinateArray();
03202       break;
03203     case GL_NORMAL_ARRAY :
03204       GLEnableNormalArray();
03205       break;
03206     case GL_SECONDARY_COLOR_ARRAY :
03207       GLEnableSecondaryColorArray();
03208       break;
03209     case GL_TEXTURE_COORD_ARRAY :
03210       GLEnableTextureCoordArray();
03211       break;
03212     case GL_VERTEX_ARRAY :
03213       GLEnableVertexArray();
03214       break;
03215     default :
03216       _GLEnableClientState( array );
03217       break;
03218   }
03219 #else
03220   _GLEnableClientState( array );
03221 #endif
03222 }
03223
03225
03226 inline  void  GLEnd( void )
03227 {
03228   NVSG_GL_STATS_FCT_COUNT();
03229   glEnd();
03230 #if !defined(NDEBUG)
03231   glContext()->m_inBeginEndLoop = false;
03232 #endif
03233   ASSERT_GL_NO_ERROR;
03234 }
03235
03237
03238 inline  void  GLEndList( void )
03239 {
03240   NVSG_GL_STATS_END_LIST();
03241   glEndList();
03242   // NOTE: no assertion on GL_NO_ERROR here, because on glEndList the GL_OUT_OF_MEMORY is to be tested!
03243 }
03244
03246
03247 inline  void  GLEndOcclusionQuery( void )
03248 {
03249   NVSG_GL_STATS_FCT_COUNT();
03250   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEndOcclusionQueryNV );
03251   glContext()->m_glFunctions->glEndOcclusionQueryNV();
03252   ASSERT_GL_NO_ERROR;
03253 }
03254
03256
03257 inline  void  GLEndQuery( GLenum target )
03258 {
03259   NVSG_GL_STATS_FCT_COUNT();
03260   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glEndQueryARB );
03261   glContext()->m_glFunctions->glEndQueryARB( target );
03262   ASSERT_GL_NO_ERROR;
03263 }
03264
03266
03267 inline  void  GLEvalCoord1d( GLdouble u )
03268 {
03269   NVSG_GL_STATS_FCT_COUNT();
03270   glEvalCoord1d( u );
03271   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03272 }
03273
03275
03276 inline  void  GLEvalCoord1f( GLfloat u )
03277 {
03278   NVSG_GL_STATS_FCT_COUNT();
03279   glEvalCoord1f( u );
03280   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03281 }
03282
03284
03285 inline  void  GLEvalCoord2d( GLdouble u, GLdouble v )
03286 {
03287   NVSG_GL_STATS_FCT_COUNT();
03288   glEvalCoord2d( u, v );
03289   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03290 }
03291
03293
03294 inline  void  GLEvalCoord2f( GLfloat u, GLfloat v )
03295 {
03296   NVSG_GL_STATS_FCT_COUNT();
03297   glEvalCoord2f( u, v );
03298   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03299 }
03300
03302
03303 inline  void  GLEvalMesh1( GLenum mode, GLint i1, GLint i2 )
03304 {
03305   NVSG_GL_STATS_FCT_COUNT();
03306   glEvalMesh1( mode, i1, i2 );
03307   ASSERT_GL_NO_ERROR;
03308 }
03309
03311
03312 inline  void  GLEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
03313 {
03314   NVSG_GL_STATS_FCT_COUNT();
03315   glEvalMesh2( mode, i1, i2, j1, j2 );
03316   ASSERT_GL_NO_ERROR;
03317 }
03318
03320
03321 inline  void  GLEvalPoint1( GLint i )
03322 {
03323   NVSG_GL_STATS_FCT_COUNT();
03324   glEvalPoint1( i );
03325   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03326 }
03327
03329
03330 inline  void  GLEvalPoint2( GLint i, GLint j )
03331 {
03332   NVSG_GL_STATS_FCT_COUNT();
03333   glEvalPoint2( i, j );
03334   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03335 }
03336
03338
03339 inline  void  GLFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
03340 {
03341   NVSG_GL_STATS_FCT_COUNT();
03342   glFeedbackBuffer( size, type, buffer );
03343   ASSERT_GL_NO_ERROR;
03344 }
03345
03347
03348 inline  void  GLFinish( void )
03349 {
03350   NVSG_GL_STATS_FCT_COUNT();
03351   glFinish();
03352   ASSERT_GL_NO_ERROR;
03353 }
03354
03356
03357 inline  void  GLFlush( void )
03358 {
03359   NVSG_GL_STATS_FCT_COUNT();
03360   glFlush();
03361   ASSERT_GL_NO_ERROR;
03362 }
03363
03365
03366 inline  void  GLFogCoordPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
03367 {
03368   GLContext * ctx = glContext();
03369 #if defined( GL_CACHING )
03370   GLContext::VertexArrayParameters parameters( 1, type, stride, pointer );
03371   if ( ctx->m_vertexArrayAttributes.m_fogCoordArrayParams != parameters )
03372 #endif
03373   {
03374     NVSG_GL_STATS_FCT_COUNT();
03375     ctx->m_glFunctions->glFogCoordPointer( type, stride, pointer );
03376     ASSERT_GL_NO_ERROR;
03377 #if defined( GL_CACHING )
03378     ctx->m_vertexArrayAttributes.m_fogCoordArrayParams = parameters;
03379 #endif
03380   }
03381 }
03382
03384
03385 inline  void  GLFogf( GLenum pname, GLfloat param )
03386 {
03387   NVSG_GL_STATS_FCT_COUNT();
03388   glFogf( pname, param );
03389   ASSERT_GL_NO_ERROR;
03390 }
03391
03393
03394 inline  void  GLFogfv( GLenum pname, const GLfloat *params )
03395 {
03396   NVSG_GL_STATS_FCT_COUNT();
03397   glFogfv( pname, params );
03398   ASSERT_GL_NO_ERROR;
03399 }
03400
03402
03403 inline  void  GLFogi( GLenum pname, GLint param )
03404 {
03405   NVSG_GL_STATS_FCT_COUNT();
03406   glFogi(pname, param);
03407   ASSERT_GL_NO_ERROR;
03408 }
03409
03411
03412 inline  void  GLFogiv( GLenum pname, const GLint *params )
03413 {
03414   NVSG_GL_STATS_FCT_COUNT();
03415   glFogiv(pname, params);
03416   ASSERT_GL_NO_ERROR;
03417 }
03418
03420
03421 inline  void  GLFrontFace( GLenum mode )
03422 {
03423 #if defined(GL_CACHING)
03424   GLContext * ctx = glContext();
03425   if ( mode != ctx->m_polygonAttributes.m_frontFaceMode )
03426 #endif
03427   {
03428     NVSG_GL_STATS_FCT_COUNT();
03429     glFrontFace( mode );
03430     ASSERT_GL_NO_ERROR;
03431 #if defined(GL_CACHING)
03432     ctx->m_polygonAttributes.m_frontFaceMode = mode;
03433 #endif
03434   }
03435 }
03436
03438
03439 inline  void  GLFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
03440 {
03441   NVSG_GL_STATS_FRUSTUM( left, right, bottom, top, zNear, zFar );
03442   glFrustum( left, right, bottom, top, zNear, zFar );
03443   ASSERT_GL_NO_ERROR;
03444 }
03445
03447
03448 inline  GLuint  GLGenLists( GLsizei range )
03449 {
03450   NVSG_GL_STATS_GEN_LISTS( range );
03451   GLuint  firstList = glGenLists( range );
03452   ASSERT_GL_NO_ERROR;
03453 #if defined( GL_CACHING )
03454   glContext()->m_glObjects->addLists(range, firstList);
03455 #endif
03456   return( firstList );
03457 }
03458
03460
03461 inline  void  GLGenOcclusionQueries( GLsizei n, GLuint *ids )
03462 {
03463   NVSG_GL_STATS_FCT_COUNT();
03464   GLContext * ctx = glContext();
03465   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenOcclusionQueriesNV );
03466   ctx->m_glFunctions->glGenOcclusionQueriesNV( n, ids );
03467   ASSERT_GL_NO_ERROR;
03468 #if defined( GL_CACHING )
03469   ctx->m_glObjects->addOcclusionQueries(n, ids);
03470 #endif
03471 }
03472
03474
03475 inline  void  GLGenPrograms( GLsizei n, GLuint *ids )
03476 {
03477   NVSG_GL_STATS_FCT_COUNT();
03478   GLContext * ctx = glContext();
03479   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenProgramsNV );
03480   ctx->m_glFunctions->glGenProgramsNV( n, ids );
03481   ASSERT_GL_NO_ERROR;
03482 #if defined( GL_CACHING )
03483   ctx->m_glObjects->addPrograms(n, ids);
03484 #endif
03485 }
03486
03488
03489 inline  void  GLGenQueries( GLsizei n, GLuint *ids )
03490 {
03491   NVSG_GL_STATS_FCT_COUNT();
03492   GLContext * ctx = glContext();
03493   NVSG_ASSERT( ctx->m_glFunctions && ctx->m_glFunctions->glGenQueriesARB );
03494   ctx->m_glFunctions->glGenQueriesARB( n, ids );
03495   ASSERT_GL_NO_ERROR;
03496 #if defined( GL_CACHING )
03497   ctx->m_glObjects->addQueries( n, ids );
03498 #endif
03499 }
03500
03502
03503 inline  void  GLGenTextures( GLsizei n, GLuint *textures )
03504 {
03505   NVSG_GL_STATS_GEN_TEXTURES( n, textures );
03506   glGenTextures( n, textures );
03507   ASSERT_GL_NO_ERROR;
03508 #if defined( GL_CACHING )
03509   glContext()->m_glObjects->addTextures(n, textures);
03510 #endif
03511 }
03512
03514
03515 inline  void  GLGetBooleanv( GLenum pname, GLboolean *params )
03516 {
03517   NVSG_GL_STATS_FCT_COUNT();
03518   glGetBooleanv( pname, params );
03519   ASSERT_GL_NO_ERROR;
03520 }
03521
03523
03524 inline  void  GLGetDoublev( GLenum pname, GLdouble *params )
03525 {
03526   NVSG_GL_STATS_FCT_COUNT();
03527   glGetDoublev( pname, params );
03528   ASSERT_GL_NO_ERROR;
03529 }
03530
03532
03533 inline  void  GLGetFloatv( GLenum pname, GLfloat *params )
03534 {
03535   NVSG_GL_STATS_FCT_COUNT();
03536   glGetFloatv( pname, params );
03537   ASSERT_GL_NO_ERROR;
03538 }
03539
03541
03542 inline  void  GLGetIntegerv( GLenum pname, GLint *params )
03543 {
03544   NVSG_GL_STATS_GET_INTEGERV( pname, params );
03545   glGetIntegerv( pname, params );
03546   ASSERT_GL_NO_ERROR;
03547 }
03548
03550
03551 inline  void  GLGetClipPlane( GLenum plane, GLdouble *equation )
03552 {
03553   NVSG_GL_STATS_FCT_COUNT();
03554   glGetClipPlane( plane, equation );
03555   ASSERT_GL_NO_ERROR;
03556 }
03557
03559
03560 inline  void  GLGetLightfv( GLenum light, GLenum pname, GLfloat *params )
03561 {
03562   NVSG_GL_STATS_FCT_COUNT();
03563   glGetLightfv( light, pname, params );
03564   ASSERT_GL_NO_ERROR;
03565 }
03566
03568
03569 inline  void  GLGetLightiv( GLenum light, GLenum pname, GLint *params )
03570 {
03571   NVSG_GL_STATS_FCT_COUNT();
03572   glGetLightiv( light, pname, params );
03573   ASSERT_GL_NO_ERROR;
03574 }
03575
03577
03578 inline  void  GLGetMapdv( GLenum target, GLenum query, GLdouble *v )
03579 {
03580   NVSG_GL_STATS_FCT_COUNT();
03581   glGetMapdv( target, query, v );
03582   ASSERT_GL_NO_ERROR;
03583 }
03584
03586
03587 inline  void  GLGetMapfv( GLenum target, GLenum query, GLfloat *v )
03588 {
03589   NVSG_GL_STATS_FCT_COUNT();
03590   glGetMapfv( target, query, v );
03591   ASSERT_GL_NO_ERROR;
03592 }
03593
03595
03596 inline  void  GLGetMapiv( GLenum target, GLenum query, GLint *v )
03597 {
03598   NVSG_GL_STATS_FCT_COUNT();
03599   glGetMapiv( target, query, v );
03600   ASSERT_GL_NO_ERROR;
03601 }
03602
03604
03605 inline  void  GLGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
03606 {
03607   NVSG_GL_STATS_FCT_COUNT();
03608   glGetMaterialfv( face, pname, params );
03609   ASSERT_GL_NO_ERROR;
03610 }
03611
03613
03614 inline  void  GLGetMaterialiv( GLenum face, GLenum pname, GLint *params )
03615 {
03616   NVSG_GL_STATS_FCT_COUNT();
03617   glGetMaterialiv( face, pname, params );
03618   ASSERT_GL_NO_ERROR;
03619 }
03620
03622 inline GLint GLGetMaxTexCoords( void )
03623 {
03624   NVSG_GL_STATS_FCT_COUNT();
03625   return( glContext()->m_maxTexCoords );
03626 }
03627
03629 inline GLint GLGetMaxTexUnits( void )
03630 {
03631   NVSG_GL_STATS_FCT_COUNT();
03632   return( glContext()->m_maxTexUnits );
03633 }
03634
03636 inline GLint GLGetMaxTexImageUnits( void )
03637 {
03638   NVSG_GL_STATS_FCT_COUNT();
03639   return glContext()->m_maxTexImageUnits;
03640 }
03641
03643
03644 inline  void  GLGetOcclusionQueryuiv( GLuint id, GLenum pname, GLuint *params )
03645 {
03646   NVSG_GL_STATS_FCT_COUNT();
03647   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetOcclusionQueryuivNV );
03648   glContext()->m_glFunctions->glGetOcclusionQueryuivNV( id, pname, params );
03649   ASSERT_GL_NO_ERROR;
03650 }
03651
03653
03654 inline  void  GLGetPixelMapfv( GLenum map, GLfloat *values )
03655 {
03656   NVSG_GL_STATS_FCT_COUNT();
03657   glGetPixelMapfv( map, values );
03658   ASSERT_GL_NO_ERROR;
03659 }
03660
03662
03663 inline  void  GLGetPixelMapuiv( GLenum map, GLuint *values )
03664 {
03665   NVSG_GL_STATS_FCT_COUNT();
03666   glGetPixelMapuiv( map, values );
03667   ASSERT_GL_NO_ERROR;
03668 }
03669
03671
03672 inline  void  GLGetPixelMapusv( GLenum map, GLushort *values )
03673 {
03674   NVSG_GL_STATS_FCT_COUNT();
03675   glGetPixelMapusv( map, values );
03676   ASSERT_GL_NO_ERROR;
03677 }
03678
03680
03681 inline  void  GLGetPointerv( GLenum pname, GLvoid* *params )
03682 {
03683   NVSG_GL_STATS_FCT_COUNT();
03684   glGetPointerv( pname, params );
03685   ASSERT_GL_NO_ERROR;
03686 }
03687
03689
03690 inline  void  GLGetPolygonStipple( GLubyte *mask )
03691 {
03692   NVSG_GL_STATS_FCT_COUNT();
03693   glGetPolygonStipple( mask );
03694   ASSERT_GL_NO_ERROR;
03695 }
03696
03698
03699 inline  void  GLGetQueryiv( GLenum target, GLenum pname, GLint *params )
03700 {
03701   NVSG_GL_STATS_FCT_COUNT();
03702   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryivARB );
03703   glContext()->m_glFunctions->glGetQueryivARB( target, pname, params );
03704   ASSERT_GL_NO_ERROR;
03705 }
03706
03708
03709 inline  void  GLGetQueryObjectiv( GLuint id, GLenum pname, GLint *params )
03710 {
03711   NVSG_GL_STATS_FCT_COUNT();
03712   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryObjectivARB );
03713   glContext()->m_glFunctions->glGetQueryObjectivARB( id, pname, params );
03714   ASSERT_GL_NO_ERROR;
03715 }
03716
03718
03719 inline  void  GLGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params )
03720 {
03721   NVSG_GL_STATS_FCT_COUNT();
03722   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glGetQueryObjectuivARB );
03723   glContext()->m_glFunctions->glGetQueryObjectuivARB( id, pname, params );
03724   ASSERT_GL_NO_ERROR;
03725 }
03726
03728
03729 inline  const GLubyte * GLGetString( GLenum name )
03730 {
03731   NVSG_GL_STATS_FCT_COUNT();
03732   const GLubyte * ret = glGetString( name );
03733   ASSERT_GL_NO_ERROR;
03734   return( ret );
03735 }
03736
03738
03739 inline  void  GLGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
03740 {
03741   NVSG_GL_STATS_FCT_COUNT();
03742   glGetTexEnvfv( target,pname, params );
03743   ASSERT_GL_NO_ERROR;
03744 }
03745
03747
03748 inline  void  GLGetTexEnviv( GLenum target, GLenum pname, GLint *params )
03749 {
03750   NVSG_GL_STATS_FCT_COUNT();
03751   glGetTexEnviv( target,pname, params );
03752   ASSERT_GL_NO_ERROR;
03753 }
03754
03756
03757 inline  void  GLGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
03758 {
03759   NVSG_GL_STATS_FCT_COUNT();
03760   glGetTexGendv( coord, pname, params );
03761   ASSERT_GL_NO_ERROR;
03762 }
03763
03765
03766 inline  void  GLGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
03767 {
03768   NVSG_GL_STATS_FCT_COUNT();
03769   glGetTexGenfv( coord, pname, params );
03770   ASSERT_GL_NO_ERROR;
03771 }
03772
03774
03775 inline  void  GLGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
03776 {
03777   NVSG_GL_STATS_FCT_COUNT();
03778   glGetTexGeniv( coord, pname, params );
03779   ASSERT_GL_NO_ERROR;
03780 }
03781
03783
03784 inline  void  GLGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels )
03785 {
03786 #if defined(GL_CACHING)
03787   _GLUpdateActiveTexture();
03788 #endif
03789   NVSG_GL_STATS_FCT_COUNT();
03790   glGetTexImage( target, level, format, type, pixels );
03791   ASSERT_GL_NO_ERROR;
03792 }
03793
03795
03796 inline  void  GLGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
03797 {
03798   NVSG_GL_STATS_FCT_COUNT();
03799   glGetTexLevelParameterfv( target, level, pname, params );
03800   ASSERT_GL_NO_ERROR;
03801 }
03802
03804
03805 inline  void  GLGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
03806 {
03807   NVSG_GL_STATS_FCT_COUNT();
03808   glGetTexLevelParameteriv( target, level, pname, params );
03809   ASSERT_GL_NO_ERROR;
03810 }
03811
03813
03814 inline  void  GLGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
03815 {
03816   NVSG_GL_STATS_FCT_COUNT();
03817   glGetTexParameterfv( target, pname, params );
03818   ASSERT_GL_NO_ERROR;
03819 }
03820
03822
03823 inline  void  GLGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
03824 {
03825   NVSG_GL_STATS_FCT_COUNT();
03826   glGetTexParameteriv( target, pname, params );
03827   ASSERT_GL_NO_ERROR;
03828 }
03829
03831
03832 inline  void  GLHint( GLenum target, GLenum mode )
03833 {
03834   NVSG_GL_STATS_FCT_COUNT();
03835   glHint( target, mode );
03836   ASSERT_GL_NO_ERROR;
03837 }
03838
03840
03841 inline  void  GLIndexd( GLdouble c )
03842 {
03843   NVSG_GL_STATS_FCT_COUNT();
03844   glIndexd( c );
03845   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03846 }
03847
03849
03850 inline  void  GLIndexf( GLfloat c )
03851 {
03852   NVSG_GL_STATS_FCT_COUNT();
03853   glIndexf( c );
03854   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03855 }
03856
03858
03859 inline  void  GLIndexi( GLint c )
03860 {
03861   NVSG_GL_STATS_FCT_COUNT();
03862   glIndexi( c );
03863   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03864 }
03865
03867
03868 inline  void  GLIndexMask( GLuint mask )
03869 {
03870   NVSG_GL_STATS_FCT_COUNT();
03871   glIndexMask( mask );
03872   ASSERT_GL_NO_ERROR;
03873 }
03874
03876
03877 inline  void  GLIndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
03878 {
03879   NVSG_GL_STATS_FCT_COUNT();
03880   glIndexPointer( type, stride, pointer );
03881   ASSERT_GL_NO_ERROR;
03882 }
03883
03885
03886 inline  void  GLIndexs( GLshort c )
03887 {
03888   NVSG_GL_STATS_FCT_COUNT();
03889   glIndexs( c );
03890   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03891 }
03892
03894
03895 inline  void  GLIndexub( GLubyte c )
03896 {
03897   NVSG_GL_STATS_FCT_COUNT();
03898   glIndexub( c );
03899   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
03900 }
03901
03903
03904 inline  void  GLInitNames( void )
03905 {
03906   NVSG_GL_STATS_FCT_COUNT();
03907   glInitNames();
03908   ASSERT_GL_NO_ERROR;
03909 }
03910
03912
03913 inline  void  GLInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer )
03914 {
03915   NVSG_GL_STATS_FCT_COUNT();
03916   glInterleavedArrays( format, stride, pointer );
03917   ASSERT_GL_NO_ERROR;
03918 }
03919
03921
03922 inline  GLboolean  GLIsEnabled( GLenum cap )
03923 {
03924   NVSG_GL_STATS_FCT_COUNT();
03925   GLboolean isEnabled = glIsEnabled( cap );
03926   ASSERT_GL_NO_ERROR;
03927   return isEnabled;
03928 }
03929
03931
03933 inline GLboolean GLIsExtensionAvailable( const std::string& extension )
03934 {
03935   NVSG_GL_STATS_FCT_COUNT();
03936   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
03937   return glContext()->m_glFunctions->isAvailable(extension);
03938 }
03939
03941
03943 inline GLboolean GLIsExtensionExported( const std::string& extension )
03944 {
03945   NVSG_GL_STATS_FCT_COUNT();
03946   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
03947   return glContext()->m_glFunctions->isExported(extension);
03948 }
03949
03951
03952 inline  GLboolean GLIsList( GLuint list )
03953 {
03954   NVSG_GL_STATS_FCT_COUNT();
03955   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
03956 #if defined( GL_CACHING )
03957   NVSG_ASSERT(!!glContext()->isDisplayList(list)==!!glIsList(list));
03958   return glContext()->isDisplayList(list);
03959 #else
03960   GLboolean ok = glIsList( list );
03961   ASSERT_GL_NO_ERROR;
03962   return( ok );
03963 #endif
03964 }
03965
03967
03968 inline  GLboolean GLIsOcclusionQuery( GLuint id )
03969 {
03970   NVSG_GL_STATS_FCT_COUNT();
03971   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsOcclusionQueryNV);
03972 #if defined( GL_CACHING )
03973   NVSG_ASSERT(!!glContext()->isOcclusionQuery(id)==!!glContext()->m_glFunctions->glIsOcclusionQueryNV(id));
03974   return( glContext()->isOcclusionQuery( id ) );
03975 #else
03976   GLboolean ok = glContext()->m_glFunctions->glIsOcclusionQueryNV( id );
03977   ASSERT_GL_NO_ERROR;
03978   return( ok );
03979 #endif
03980 }
03981
03983
03984 inline  GLboolean GLIsProgram(GLuint id)
03985 {
03986   NVSG_GL_STATS_FCT_COUNT();
03987   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsProgramNV);
03988 #if defined( GL_CACHING )
03989   NVSG_ASSERT(!!glContext()->isProgram(id)==!!glContext()->m_glFunctions->glIsProgramNV(id));
03990   return glContext()->isProgram(id);
03991 #else
03992   GLboolean ok = glContext()->m_glFunctions->glIsProgramNV( id );
03993   ASSERT_GL_NO_ERROR;
03994   return( ok );
03995 #endif
03996 }
03997
03999
04000 inline  GLboolean GLIsQuery( GLuint id )
04001 {
04002   NVSG_GL_STATS_FCT_COUNT();
04003   NVSG_ASSERT(glContext()->m_glFunctions && glContext()->m_glFunctions->glIsQueryARB);
04004 #if defined( GL_CACHING )
04005   NVSG_ASSERT(!!glContext()->isQuery(id)==!!glContext()->m_glFunctions->glIsQueryARB(id));
04006   return glContext()->isQuery(id);
04007 #else
04008   GLboolean ok = glContext()->m_glFunctions->glIsQueryARB( id );
04009   ASSERT_GL_NO_ERROR;
04010   return( ok );
04011 #endif
04012 }
04013
04015
04016 inline  GLboolean GLIsTexture( GLuint texture )
04017 {
04018   NVSG_GL_STATS_IS_TEXTURE( texture );
04019   NVSG_ASSERT(glContext() && glContext()->m_glFunctions);
04020 #if defined( GL_CACHING )
04021   NVSG_ASSERT(!!glContext()->isTexture(texture)==!!glIsTexture(texture));
04022   return(glContext()->isTexture(texture));
04023 #else
04024   GLboolean ok = glIsTexture( texture );
04025   ASSERT_GL_NO_ERROR;
04026   return( ok );
04027 #endif
04028 }
04029
04031
04033 inline  void  GLLightAmbient( GLenum light, const GLfloat *params )
04034 {
04035 #if defined( GL_CACHING )
04036   GLContext * ctx = glContext();
04037   if ( !equal4fv( params, &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_ambient[0] ) )
04038   {
04039 # if !defined(NDEBUG)
04040     GLfloat f[4];
04041     glGetLightfv( light, GL_AMBIENT, f );
04042     NVSG_ASSERT( equal4fv( f, &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_ambient[0] ) );
04043 # endif
04044 #endif
04045     _GLLightfv( light, GL_AMBIENT, params );
04046 #if defined( GL_CACHING )
04047     memcpy( &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_ambient[0], params, 4*sizeof(GLfloat) );
04048   }
04049 #endif
04050 }
04051
04053
04055 inline  void  GLLightConstantAttenuation( GLenum light, GLfloat param )
04056 {
04057 #if defined( GL_CACHING )
04058   GLContext * ctx = glContext();
04059   if ( ! equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[0], param ) )
04060   {
04061 # if !defined(NDEBUG)
04062     GLfloat f;
04063     glGetLightfv( light, GL_CONSTANT_ATTENUATION, &f );
04064     NVSG_ASSERT( equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[0], f ) );
04065 # endif
04066 #endif
04067     _GLLightf( light, GL_CONSTANT_ATTENUATION, param );
04068 #if defined( GL_CACHING )
04069     ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[0] = param;
04070   }
04071 #endif
04072 }
04073
04075
04077 inline  void  GLLightDiffuse( GLenum light, const GLfloat *params )
04078 {
04079 #if defined( GL_CACHING )
04080   GLContext * ctx = glContext();
04081   if ( !equal4fv( params, &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_diffuse[0] ) )
04082   {
04083 # if !defined(NDEBUG)
04084     GLfloat f[4];
04085     glGetLightfv( light, GL_DIFFUSE, f );
04086     NVSG_ASSERT( equal4fv( f, &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_diffuse[0] ) );
04087 # endif
04088 #endif
04089     _GLLightfv( light, GL_DIFFUSE, params );
04090 #if defined( GL_CACHING )
04091     memcpy( &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_diffuse[0], params, 4*sizeof(GLfloat) );
04092   }
04093 #endif
04094 }
04095
04097
04099 inline  void  GLLightLinearAttenuation( GLenum light, GLfloat param )
04100 {
04101 #if defined( GL_CACHING )
04102   GLContext * ctx = glContext();
04103   if ( ! equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[1], param ) )
04104   {
04105 # if !defined(NDEBUG)
04106     GLfloat f;
04107     glGetLightfv( light, GL_LINEAR_ATTENUATION, &f );
04108     NVSG_ASSERT( equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[1], f ) );
04109 # endif
04110 #endif
04111     _GLLightf( light, GL_LINEAR_ATTENUATION, param );
04112 #if defined( GL_CACHING )
04113     ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[1] = param;
04114   }
04115 #endif
04116 }
04117
04119
04120 inline  void  GLLightPosition( GLenum light, const GLfloat *params )
04121 {
04122 #if defined( GL_CACHING )
04123   _GLLightfv( light, GL_POSITION, params );
04124 #else
04125   GLLightfv( light, GL_POSITION, params );
04126 #endif
04127 }
04128
04130
04132 inline  void  GLLightQuadraticAttenuation( GLenum light, GLfloat param )
04133 {
04134 #if defined( GL_CACHING )
04135   GLContext * ctx = glContext();
04136   if ( ! equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[2], param ) )
04137   {
04138 # if !defined(NDEBUG)
04139     GLfloat f;
04140     glGetLightfv( light, GL_QUADRATIC_ATTENUATION, &f );
04141     NVSG_ASSERT( equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[2], f ) );
04142 # endif
04143 #endif
04144     _GLLightf( light, GL_QUADRATIC_ATTENUATION, param );
04145 #if defined( GL_CACHING )
04146     ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_attenuation[2] = param;
04147   }
04148 #endif
04149 }
04150
04152
04154 inline  void  GLLightSpecular( GLenum light, const GLfloat *params )
04155 {
04156 #if defined( GL_CACHING )
04157   GLContext * ctx = glContext();
04158   if ( !equal4fv( params, &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_specular[0] ) )
04159   {
04160 # if !defined(NDEBUG)
04161     GLfloat f[4];
04162     glGetLightfv( light, GL_SPECULAR, f );
04163     NVSG_ASSERT( equal4fv( f, &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_specular[0] ) );
04164 # endif
04165 #endif
04166     _GLLightfv( light, GL_SPECULAR, params );
04167 #if defined( GL_CACHING )
04168     memcpy( &ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_specular[0], params, 4*sizeof(GLfloat) );
04169   }
04170 #endif
04171 }
04172
04174
04176 inline  void  GLLightSpotCutoff( GLenum light, GLfloat param )
04177 {
04178 #if defined( GL_CACHING )
04179   GLContext * ctx = glContext();
04180   if ( !equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotCutoff, param ) )
04181   {
04182 # if !defined(NDEBUG)
04183     GLfloat f;
04184     glGetLightfv( light, GL_SPOT_CUTOFF, &f );
04185     NVSG_ASSERT( equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotCutoff, f ) );
04186 # endif
04187 #endif
04188     _GLLightf( light, GL_SPOT_CUTOFF, param );
04189 #if defined( GL_CACHING )
04190     ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotCutoff = param;
04191   }
04192 #endif
04193 }
04194
04196
04197 inline  void  GLLightSpotDirection( GLenum light, const GLfloat *params )
04198 {
04199 #if defined( GL_CACHING )
04200   _GLLightfv( light, GL_SPOT_DIRECTION, params );
04201 #else
04202   GLLightfv( light, GL_SPOT_DIRECTION, params );
04203 #endif
04204 }
04205
04207
04209 inline  void  GLLightSpotExponent( GLenum light, GLfloat param )
04210 {
04211 #if defined( GL_CACHING )
04212   GLContext * ctx = glContext();
04213   if ( !equalf( ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotExponent, param ) )
04214   {
04215 # if !defined(NDEBUG)
04216     GLfloat f;
04217     glGetLightfv( light, GL_SPOT_EXPONENT, &f );
04218     NVSG_ASSERT( equalf(ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotExponent, f) );
04219 # endif
04220 #endif
04221     _GLLightf( light, GL_SPOT_EXPONENT, param );
04222 #if defined( GL_CACHING )
04223     ctx->m_lightingAttributes.m_lightParameters[light-GL_LIGHT0].m_spotExponent = param;
04224   }
04225 #endif
04226 }
04227
04229
04230 inline  void  GLLightf( GLenum light, GLenum pname, GLfloat param )
04231 {
04232 #if defined( GL_CACHING )
04233   switch( pname )
04234   {
04235     case GL_CONSTANT_ATTENUATION :
04236       GLLightConstantAttenuation( light, param );
04237       break;
04238     case GL_LINEAR_ATTENUATION :
04239       GLLightLinearAttenuation( light, param );
04240       break;
04241     case GL_QUADRATIC_ATTENUATION :
04242       GLLightQuadraticAttenuation( light, param );
04243       break;
04244     case GL_SPOT_CUTOFF :
04245       GLLightSpotCutoff( light, param );
04246       break;
04247     case GL_SPOT_EXPONENT :
04248       GLLightSpotExponent( light, param );
04249       break;
04250     default :
04251       _GLLightf( light, pname, param );
04252       break;
04253   }
04254 #else
04255   _GLLightf( light, pname, param );
04256 #endif
04257 }
04258
04260
04261 inline  void  GLLightfv( GLenum light, GLenum pname, const GLfloat *params )
04262 {
04263 #if defined( GL_CACHING )
04264   switch( pname )
04265   {
04266     case GL_AMBIENT :
04267       GLLightAmbient( light, params );
04268       break;
04269     case GL_CONSTANT_ATTENUATION :
04270       GLLightConstantAttenuation( light, params[0] );
04271       break;
04272     case GL_DIFFUSE :
04273       GLLightDiffuse( light, params );
04274       break;
04275     case GL_LINEAR_ATTENUATION :
04276       GLLightLinearAttenuation( light, params[0] );
04277       break;
04278     case GL_POSITION :
04279       GLLightPosition( light, params );
04280       break;
04281     case GL_QUADRATIC_ATTENUATION :
04282       GLLightQuadraticAttenuation( light, params[0] );
04283       break;
04284     case GL_SPECULAR :
04285       GLLightSpecular( light, params );
04286       break;
04287     case GL_SPOT_CUTOFF :
04288       GLLightSpotCutoff( light, params[0] );
04289       break;
04290     case GL_SPOT_DIRECTION :
04291       GLLightSpotDirection( light, params );
04292       break;
04293     case GL_SPOT_EXPONENT :
04294       GLLightSpotExponent( light, params[0] );
04295       break;
04296     default :
04297       _GLLightfv( light, pname, params );
04298       break;
04299   }
04300 #else
04301   _GLLightfv( light, pname, params );
04302 #endif
04303 }
04304
04306
04307 inline  void  GLLighti( GLenum light, GLenum pname, GLint param )
04308 {
04309 #if defined( GL_CACHING )
04310   switch( pname )
04311   {
04312     case GL_CONSTANT_ATTENUATION :
04313       GLLightConstantAttenuation( light, (GLfloat)param );
04314       break;
04315     case GL_LINEAR_ATTENUATION :
04316       GLLightLinearAttenuation( light, (GLfloat)param );
04317       break;
04318     case GL_QUADRATIC_ATTENUATION :
04319       GLLightQuadraticAttenuation( light, (GLfloat)param );
04320       break;
04321     case GL_SPOT_CUTOFF :
04322       GLLightSpotCutoff( light, (GLfloat)param );
04323       break;
04324     case GL_SPOT_EXPONENT :
04325       GLLightSpotExponent( light, (GLfloat)param );
04326       break;
04327     default :
04328       _GLLighti( light, pname, param );
04329       break;
04330   }
04331 #else
04332   _GLLighti( light, pname, param );
04333 #endif
04334 }
04335
04337 inline  void  GLintToGLfloat( const GLint *params, GLfloat *fParams )
04338 {
04339   for ( size_t i=0 ; i<4 ; i++ )
04340   {
04341     fParams[i] = (GLfloat)params[i] / INT_MAX;
04342   }
04343 }
04344
04346
04347 inline  void  GLLightiv( GLenum light, GLenum pname, GLint *params )
04348 {
04349 #if defined( GL_CACHING )
04350   GLfloat fParams[4];
04351   switch( pname )
04352   {
04353     case GL_AMBIENT :
04354       GLintToGLfloat( params, fParams );
04355       GLLightAmbient( light, fParams );
04356       break;
04357     case GL_CONSTANT_ATTENUATION :
04358       GLLightConstantAttenuation( light, (GLfloat)params[0] );
04359       break;
04360     case GL_DIFFUSE :
04361       GLintToGLfloat( params, fParams );
04362       GLLightDiffuse( light, fParams );
04363       break;
04364     case GL_LINEAR_ATTENUATION :
04365       GLLightLinearAttenuation( light, (GLfloat)params[0] );
04366       break;
04367     case GL_POSITION :
04368       for ( size_t i=0 ; i<4 ; i++ )
04369       {
04370         fParams[i] = (GLfloat)params[i];
04371       }
04372       GLLightPosition( light, fParams );
04373       break;
04374     case GL_QUADRATIC_ATTENUATION :
04375       GLLightQuadraticAttenuation( light, (GLfloat)params[0] );
04376       break;
04377     case GL_SPECULAR :
04378       GLintToGLfloat( params, fParams );
04379       GLLightSpecular( light, fParams );
04380       break;
04381     case GL_SPOT_CUTOFF :
04382       GLLightSpotCutoff( light, (GLfloat)params[0] );
04383       break;
04384     case GL_SPOT_DIRECTION :
04385       for ( size_t i=0 ; i<4 ; i++ )
04386       {
04387         fParams[i] = (GLfloat)params[i];
04388       }
04389       GLLightSpotDirection( light, fParams );
04390       break;
04391     case GL_SPOT_EXPONENT :
04392       GLLightSpotExponent( light, (GLfloat)params[0] );
04393       break;
04394     default :
04395       _GLLightiv( light, pname, params );
04396       break;
04397   }
04398 #else
04399   _GLLightiv( light, pname, params );
04400 #endif
04401 }
04402
04404
04405 inline  void  GLLightModelAmbient( const GLfloat * params )
04406 {
04407 #if defined( GL_CACHING )
04408   GLContext * ctx = glContext();
04409   if ( !equal4fv( &ctx->m_lightingAttributes.m_lightModelAmbient[0], params ) )
04410 #endif
04411   {
04412     _GLLightModelfv( GL_LIGHT_MODEL_AMBIENT, params );
04413 #if defined( GL_CACHING )
04414     memcpy( &ctx->m_lightingAttributes.m_lightModelAmbient[0], params, 4*sizeof(float) );
04415 #endif
04416   }
04417 }
04418
04420
04421 inline  void  GLLightModelLocalViewer( GLint param )
04422 {
04423 #if defined( GL_CACHING )
04424   GLContext * ctx = glContext();
04425   if ( ctx->m_lightingAttributes.m_lightModelLocalViewer != !!param )
04426   {
04427 # if !defined(NDEBUG)
04428     GLboolean lv;
04429     glGetBooleanv( GL_LIGHT_MODEL_LOCAL_VIEWER, &lv );
04430     NVSG_ASSERT( ctx->m_lightingAttributes.m_lightModelLocalViewer == !!lv );
04431 # endif
04432 #endif
04433     _GLLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, param );
04434 #if defined( GL_CACHING )
04435     ctx->m_lightingAttributes.m_lightModelLocalViewer = !!param;
04436   }
04437 #endif
04438 }
04439
04441
04442 inline  void  GLLightModelTwoSide( GLint param )
04443 {
04444   GLContext * ctx = glContext();
04445 #if defined( GL_CACHING )
04446   if ( ctx->m_lightingAttributes.m_lightModelTwoSide != !!param )
04447 #endif
04448   {
04449     if ( ! ctx->m_locks.m_lightModelTwoSide )
04450     {
04451 #if !defined( NDEBUG ) && defined( GL_CACHING )
04452       GLboolean lv;
04453       glGetBooleanv( GL_LIGHT_MODEL_TWO_SIDE, &lv );
04454       NVSG_ASSERT( ctx->m_lightingAttributes.m_lightModelTwoSide == !!lv );
04455 #endif
04456       _GLLightModeli( GL_LIGHT_MODEL_TWO_SIDE, param );
04457 #if defined( GL_CACHING )
04458       ctx->m_lightingAttributes.m_lightModelTwoSide = !!param;
04459 #endif
04460     }
04461   }
04462 }
04463
04464 inline void GLLightModelTwoSideLock( GLint param )
04465 {
04466   NVSG_ASSERT( !glContext()->m_locks.m_lightModelTwoSide );
04467   GLLightModelTwoSide( param );
04468   glContext()->m_locks.m_lightModelTwoSide = true;
04469 }
04470
04471 inline void GLLightModelTwoSideUnlock( GLint param )
04472 {
04473   NVSG_ASSERT( glContext()->m_locks.m_lightModelTwoSide );
04474   glContext()->m_locks.m_lightModelTwoSide = false;
04475   GLLightModelTwoSide( param );
04476 }
04477
04479
04480 inline  void  GLLightModelf( GLenum pname, GLfloat param )
04481 {
04482   switch( pname )
04483   {
04484     case GL_LIGHT_MODEL_LOCAL_VIEWER :
04485       GLLightModelLocalViewer( (GLint)param );
04486       break;
04487     case GL_LIGHT_MODEL_TWO_SIDE :
04488       GLLightModelTwoSide( (GLint)param );
04489       break;
04490     default :
04491       _GLLightModelf( pname, param );
04492       break;
04493   }
04494 }
04495
04497
04498 inline  void  GLLightModelfv( GLenum pname, const GLfloat *params )
04499 {
04500   switch( pname )
04501   {
04502     case GL_LIGHT_MODEL_AMBIENT :
04503       GLLightModelAmbient( params );
04504       break;
04505     case GL_LIGHT_MODEL_LOCAL_VIEWER :
04506       GLLightModelLocalViewer( (GLint)params[0] );
04507       break;
04508     case GL_LIGHT_MODEL_TWO_SIDE :
04509       GLLightModelTwoSide( (GLint)params[0] );
04510       break;
04511     default :
04512       _GLLightModelfv( pname, params );
04513       break;
04514   }
04515 }
04516
04518
04519 inline  void  GLLightModeli( GLenum pname, GLint param )
04520 {
04521   switch( pname )
04522   {
04523     case GL_LIGHT_MODEL_LOCAL_VIEWER :
04524       GLLightModelLocalViewer( param );
04525       break;
04526     case GL_LIGHT_MODEL_TWO_SIDE :
04527       GLLightModelTwoSide( param );
04528       break;
04529     default :
04530       _GLLightModeli( pname, param );
04531       break;
04532   }
04533 }
04534
04536
04537 inline  void  GLLightModeliv( GLenum pname, const GLint *params )
04538 {
04539   switch( pname )
04540   {
04541     case GL_LIGHT_MODEL_LOCAL_VIEWER :
04542       GLLightModelLocalViewer( params[0] );
04543       break;
04544     case GL_LIGHT_MODEL_TWO_SIDE :
04545       GLLightModelTwoSide( params[0] );
04546       break;
04547     default :
04548       _GLLightModeliv( pname, params );
04549       break;
04550   }
04551 }
04552
04554
04555 inline  void  GLLineStipple( GLint factor, GLushort pattern )
04556 {
04557 #if defined( GL_CACHING )
04558   GLContext * ctx = glContext();
04559   if ( ( ctx->m_lineAttributes.m_stippleRepeat != factor ) || ( ctx->m_lineAttributes.m_stipplePattern != pattern ) )
04560 #endif
04561   {
04562     NVSG_GL_STATS_FCT_COUNT();
04563     glLineStipple( factor, pattern );
04564     ASSERT_GL_NO_ERROR;
04565 #if defined( GL_CACHING )
04566     ctx->m_lineAttributes.m_stippleRepeat = factor;
04567     ctx->m_lineAttributes.m_stipplePattern = pattern;
04568 #endif
04569   }
04570 }
04571
04573
04574 inline  void  GLLineWidth( GLfloat width )
04575 {
04576 #if defined( GL_CACHING )
04577   GLContext * ctx = glContext();
04578   if ( ctx->m_lineAttributes.m_width != width )
04579   {
04580 # if !defined(NDEBUG)
04581     GLfloat f;
04582     glGetFloatv( GL_LINE_WIDTH, &f );
04583     NVSG_ASSERT( ctx->m_lineAttributes.m_width == f );
04584 # endif
04585 #endif
04586     NVSG_GL_STATS_LINE_WIDTH( width );
04587     glLineWidth( width );
04588     ASSERT_GL_NO_ERROR;
04589 #if defined( GL_CACHING )
04590     ctx->m_lineAttributes.m_width = width;
04591   }
04592 #endif
04593 }
04594
04596
04597 inline  void  GLListBase( GLuint base )
04598 {
04599   NVSG_GL_STATS_FCT_COUNT();
04600   glListBase( base );
04601   ASSERT_GL_NO_ERROR;
04602 }
04603
04605
04606 inline  void  GLLoadIdentity( void )
04607 {
04608   NVSG_GL_STATS_LOAD_IDENTITY();
04609 #if defined( GL_CACHING )
04610   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
04611   { // note: we have a texture matrix stack per unit
04612     _GLUpdateActiveTexture();
04613   }
04614 #endif
04615   glLoadIdentity();
04616   ASSERT_GL_NO_ERROR;
04617 }
04618
04620
04621 inline  void  GLLoadMatrixd( const GLdouble *m )
04622 {
04623   NVSG_GL_STATS_LOAD_MATRIXD( m );
04624 #if defined( GL_CACHING )
04625   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
04626   { // note: we have a texture matrix stack per unit
04627     _GLUpdateActiveTexture();
04628   }
04629 #endif
04630   glLoadMatrixd( m );
04631   ASSERT_GL_NO_ERROR;
04632 }
04633
04635
04636 inline  void  GLLoadMatrixf( const GLfloat *m )
04637 {
04638   NVSG_GL_STATS_LOAD_MATRIXF( m );
04639 #if defined( GL_CACHING )
04640   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
04641   { // note: we have a texture matrix stack per unit
04642     _GLUpdateActiveTexture();
04643   }
04644 #endif
04645   glLoadMatrixf( m );
04646   ASSERT_GL_NO_ERROR;
04647 }
04648
04650
04651 inline  void  GLLoadTransposedMatrixd( const GLdouble *m )
04652 {
04653   NVSG_GL_STATS_LOAD_MATRIXD( m );
04654 #if defined( GL_CACHING )
04655   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
04656   { // note: we have a texture matrix stack per unit
04657     _GLUpdateActiveTexture();
04658   }
04659 #endif
04660   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLoadTransposeMatrixd );
04661   glContext()->m_glFunctions->glLoadTransposeMatrixd( m );
04662   ASSERT_GL_NO_ERROR;
04663 }
04664
04666
04667 inline  void  GLLoadTransposeMatrixf( const GLfloat *m )
04668 {
04669   NVSG_GL_STATS_LOAD_MATRIXF( m );
04670 #if defined( GL_CACHING )
04671   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
04672   { // note: we have a texture matrix stack per unit
04673     _GLUpdateActiveTexture();
04674   }
04675 #endif
04676   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLoadTransposeMatrixf );
04677   glContext()->m_glFunctions->glLoadTransposeMatrixf( m );
04678   ASSERT_GL_NO_ERROR;
04679 }
04680
04682
04683 inline  void  GLLoadName( GLuint name )
04684 {
04685   NVSG_GL_STATS_FCT_COUNT();
04686   glLoadName( name );
04687   ASSERT_GL_NO_ERROR;
04688 }
04689
04691
04692 inline  void  GLLoadProgram( GLenum target, GLuint id, GLsizei len, const GLubyte *program )
04693 {
04694   NVSG_GL_STATS_FCT_COUNT();
04695   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glLoadProgramNV );
04696   glContext()->m_glFunctions->glLoadProgramNV( target, id, len, program );
04697 #if !defined(NDEBUG)
04698   ASSERT_GL_NO_ERROR;
04699   GLint errorPos;
04700   glGetIntegerv( GL_PROGRAM_ERROR_POSITION_NV, &errorPos );
04701   NVSG_ASSERT( errorPos == -1 );
04702 #endif
04703 }
04704
04706
04707 inline  void  GLLogicOp( GLenum opcode )
04708 {
04709   NVSG_GL_STATS_FCT_COUNT();
04710   glLogicOp( opcode );
04711   ASSERT_GL_NO_ERROR;
04712 }
04713
04715
04716 inline  void  GLMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
04717 {
04718   NVSG_GL_STATS_FCT_COUNT();
04719   glMap1d( target, u1, u2, stride, order, points );
04720   ASSERT_GL_NO_ERROR;
04721 }
04722
04724
04725 inline  void  GLMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
04726 {
04727   NVSG_GL_STATS_FCT_COUNT();
04728   glMap1f( target, u1, u2, stride, order, points );
04729   ASSERT_GL_NO_ERROR;
04730 }
04731
04733
04734 inline  void  GLMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
04735 {
04736   NVSG_GL_STATS_FCT_COUNT();
04737   glMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
04738   ASSERT_GL_NO_ERROR;
04739 }
04740
04742
04743 inline  void  GLMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
04744 {
04745   NVSG_GL_STATS_FCT_COUNT();
04746   glMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
04747   ASSERT_GL_NO_ERROR;
04748 }
04749
04751
04752 inline  void  GLMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
04753 {
04754   NVSG_GL_STATS_FCT_COUNT();
04755   glMapGrid1d( un, u1, u2 );
04756   ASSERT_GL_NO_ERROR;
04757 }
04758
04760
04761 inline  void  GLMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
04762 {
04763   NVSG_GL_STATS_FCT_COUNT();
04764   glMapGrid1f( un, u1, u2 );
04765   ASSERT_GL_NO_ERROR;
04766 }
04767
04769
04770 inline  void  GLMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
04771 {
04772   NVSG_GL_STATS_FCT_COUNT();
04773   glMapGrid2d( un, u1, u2, vn, v1, v2 );
04774   ASSERT_GL_NO_ERROR;
04775 }
04776
04778
04779 inline  void  GLMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
04780 {
04781   NVSG_GL_STATS_FCT_COUNT();
04782   glMapGrid2f( un, u1, u2, vn, v1, v2 );
04783   ASSERT_GL_NO_ERROR;
04784 }
04785
04787
04789 inline  void  GLMaterialShininessBack( GLfloat param )
04790 {
04791 #if defined( GL_CACHING )
04792   GLContext * ctx = glContext();
04793   if ( !equalf( ctx->m_lightingAttributes.m_materialShininess[0], param ) )
04794   {
04795 # if !defined(NDEBUG)
04796     GLfloat f;
04797     glGetMaterialfv( GL_BACK, GL_SHININESS, &f );
04798     NVSG_ASSERT( equalf( ctx->m_lightingAttributes.m_materialShininess[0], f ) );
04799 # endif
04800 #endif
04801     _GLMaterialf( GL_BACK, GL_SHININESS, param );
04802 #if defined( GL_CACHING )
04803     ctx->m_lightingAttributes.m_materialShininess[0] = param;
04804   }
04805 #endif
04806 }
04807
04809
04811 inline  void  GLMaterialShininessFront( GLfloat param )
04812 {
04813 #if defined( GL_CACHING )
04814   GLContext * ctx = glContext();
04815   if ( !equalf( ctx->m_lightingAttributes.m_materialShininess[1], param ) )
04816   {
04817 # if !defined(NDEBUG)
04818     GLfloat f;
04819     glGetMaterialfv( GL_FRONT, GL_SHININESS, &f );
04820     NVSG_ASSERT( equalf( ctx->m_lightingAttributes.m_materialShininess[1], f ) );
04821 # endif
04822 #endif
04823     _GLMaterialf( GL_FRONT, GL_SHININESS, param );
04824 #if defined( GL_CACHING )
04825     ctx->m_lightingAttributes.m_materialShininess[1] = param;
04826   }
04827 #endif
04828 }
04829
04831
04833 inline  void  GLMaterialShininessFrontAndBack( GLfloat param )
04834 {
04835 #if defined( GL_CACHING )
04836   GLContext * ctx = glContext();
04837   if (  !equalf( ctx->m_lightingAttributes.m_materialShininess[0], param )
04838      || !equalf( ctx->m_lightingAttributes.m_materialShininess[1], param ) )
04839   {
04840 # if !defined(NDEBUG)
04841     GLfloat f0, f1;
04842     glGetMaterialfv( GL_BACK, GL_SHININESS, &f0 );
04843     glGetMaterialfv( GL_FRONT, GL_SHININESS, &f1 );
04844     NVSG_ASSERT(    equalf( ctx->m_lightingAttributes.m_materialShininess[0], f0 )
04845                 &&  equalf( ctx->m_lightingAttributes.m_materialShininess[1], f1 ) );
04846 # endif
04847 #endif
04848     _GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param );
04849 #if defined( GL_CACHING )
04850     ctx->m_lightingAttributes.m_materialShininess[0] = param;
04851     ctx->m_lightingAttributes.m_materialShininess[1] = param;
04852   }
04853 #endif
04854 }
04855
04857
04859 inline  void  GLMaterialShininess( GLenum face, GLfloat param )
04860 {
04861 #if defined( GL_CACHING )
04862   switch( face )
04863   {
04864     case GL_BACK :
04865       GLMaterialShininessBack( param );
04866       break;
04867     case GL_FRONT :
04868       GLMaterialShininessFront( param );
04869       break;
04870     case GL_FRONT_AND_BACK :
04871       GLMaterialShininessFrontAndBack( param );
04872       break;
04873     default :
04874       NVSG_ASSERT( false );
04875       break;
04876   }
04877 #else
04878   GLMaterialf( face, GL_SHININESS, param );
04879 #endif
04880 }
04881
04883
04885 inline  void  GLMaterialAmbientBack( const GLfloat *params )
04886 {
04887 #if defined( GL_CACHING )
04888   GLContext * ctx = glContext();
04889   if ( ctx->m_lightingAttributes.m_colorMaterial )
04890   {
04891     _GLMaterialfv( GL_BACK, GL_AMBIENT, params );
04892   }
04893   else if ( !equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[0][0], params ) )
04894   {
04895 # if !defined(NDEBUG)
04896     GLfloat p[4];
04897     glGetMaterialfv( GL_BACK, GL_AMBIENT, p );
04898     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[0][0], p ) );
04899 # endif
04900     _GLMaterialfv( GL_BACK, GL_AMBIENT, params );
04901     memcpy( &ctx->m_lightingAttributes.m_materialAmbient[0][0], params, 4*sizeof(float) );
04902   }
04903 #else
04904   _GLMaterialfv( GL_BACK, GL_AMBIENT, params );
04905 #endif
04906 }
04907
04909
04911 inline  void  GLMaterialAmbientFront( const GLfloat *params )
04912 {
04913 #if defined( GL_CACHING )
04914   GLContext * ctx = glContext();
04915   if ( ctx->m_lightingAttributes.m_colorMaterial )
04916   {
04917     _GLMaterialfv( GL_FRONT, GL_AMBIENT, params );
04918   }
04919   else if ( !equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[1][0], params ) )
04920   {
04921 # if !defined(NDEBUG)
04922     GLfloat p[4];
04923     glGetMaterialfv( GL_FRONT, GL_AMBIENT, p );
04924     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[1][0], p ) );
04925 # endif
04926     _GLMaterialfv( GL_FRONT, GL_AMBIENT, params );
04927     memcpy( &ctx->m_lightingAttributes.m_materialAmbient[1][0], params, 4*sizeof(float) );
04928   }
04929 #else
04930   _GLMaterialfv( GL_FRONT, GL_AMBIENT, params );
04931 #endif
04932 }
04933
04935
04937 inline  void  GLMaterialAmbientFrontAndBack( const GLfloat *params )
04938 {
04939 #if defined( GL_CACHING )
04940   GLContext * ctx = glContext();
04941   if (  ctx->m_lightingAttributes.m_colorMaterial )
04942   {
04943     _GLMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, params );
04944   }
04945   else if (   !equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[0][0], params )
04946           ||  !equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[1][0], params ) )
04947   {
04948 # if !defined(NDEBUG)
04949     GLfloat p0[4], p1[4];
04950     glGetMaterialfv( GL_BACK, GL_AMBIENT, p0 );
04951     glGetMaterialfv( GL_FRONT, GL_AMBIENT, p1 );
04952     NVSG_ASSERT(    equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[0][0], p0 )
04953                 &&  equal4fv( &ctx->m_lightingAttributes.m_materialAmbient[1][0], p1 ) );
04954 # endif
04955     _GLMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, params );
04956     memcpy( &ctx->m_lightingAttributes.m_materialAmbient[0][0], params, 4*sizeof(float) );
04957     memcpy( &ctx->m_lightingAttributes.m_materialAmbient[1][0], params, 4*sizeof(float) );
04958   }
04959 #else
04960   _GLMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, params );
04961 #endif
04962 }
04963
04965
04967 inline  void  GLMaterialAmbient( GLenum face, const GLfloat *params )
04968 {
04969 #if defined( GL_CACHING )
04970   switch( face )
04971   {
04972     case GL_BACK :
04973       GLMaterialAmbientBack( params );
04974       break;
04975     case GL_FRONT :
04976       GLMaterialAmbientFront( params );
04977       break;
04978     case GL_FRONT_AND_BACK :
04979       GLMaterialAmbientFrontAndBack( params );
04980       break;
04981     default :
04982       NVSG_ASSERT( false );
04983       break;
04984   }
04985 #else
04986   GLMaterialfv( face, GL_AMBIENT, params );
04987 #endif
04988 }
04989
04991
04993 inline  void  GLMaterialDiffuseBack( const GLfloat *params )
04994 {
04995 #if defined( GL_CACHING )
04996   GLContext * ctx = glContext();
04997   if ( ctx->m_lightingAttributes.m_colorMaterial )
04998   {
04999     _GLMaterialfv( GL_BACK, GL_DIFFUSE, params );
05000   }
05001   else if ( !equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[0][0], params ) )
05002   {
05003 # if !defined(NDEBUG)
05004     GLfloat p[4];
05005     glGetMaterialfv( GL_BACK, GL_DIFFUSE, p );
05006     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[0][0], p ) );
05007 # endif
05008     _GLMaterialfv( GL_BACK, GL_DIFFUSE, params );
05009     memcpy( &ctx->m_lightingAttributes.m_materialDiffuse[0][0], params, 4*sizeof(float) );
05010   }
05011 #else
05012   _GLMaterialfv( GL_BACK, GL_DIFFUSE, params );
05013 #endif
05014 }
05015
05017
05019 inline  void  GLMaterialDiffuseFront( const GLfloat *params )
05020 {
05021 #if defined( GL_CACHING )
05022   GLContext * ctx = glContext();
05023   if ( ctx->m_lightingAttributes.m_colorMaterial )
05024   {
05025     _GLMaterialfv( GL_FRONT, GL_DIFFUSE, params );
05026   }
05027   else if ( !equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[1][0], params ) )
05028   {
05029 # if !defined(NDEBUG)
05030     GLfloat p[4];
05031     glGetMaterialfv( GL_FRONT, GL_DIFFUSE, p );
05032     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[1][0], p ) );
05033 # endif
05034     _GLMaterialfv( GL_FRONT, GL_DIFFUSE, params );
05035     memcpy( &ctx->m_lightingAttributes.m_materialDiffuse[1][0], params, 4*sizeof(float) );
05036   }
05037 #else
05038   _GLMaterialfv( GL_FRONT, GL_DIFFUSE, params );
05039 #endif
05040 }
05041
05043
05045 inline  void  GLMaterialDiffuseFrontAndBack( const GLfloat *params )
05046 {
05047 #if defined( GL_CACHING )
05048   GLContext * ctx = glContext();
05049   if ( ctx->m_lightingAttributes.m_colorMaterial )
05050   {
05051     _GLMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, params );
05052   }
05053   else if (   !equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[0][0], params )
05054           ||  !equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[1][0], params ) )
05055   {
05056 # if !defined(NDEBUG)
05057     GLfloat p0[4], p1[4];
05058     glGetMaterialfv( GL_BACK, GL_DIFFUSE, p0 );
05059     glGetMaterialfv( GL_FRONT, GL_DIFFUSE, p1 );
05060     NVSG_ASSERT(    equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[0][0], p0 )
05061                 &&  equal4fv( &ctx->m_lightingAttributes.m_materialDiffuse[1][0], p1 ) );
05062 # endif
05063     _GLMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, params );
05064     memcpy( &ctx->m_lightingAttributes.m_materialDiffuse[0][0], params, 4*sizeof(float) );
05065     memcpy( &ctx->m_lightingAttributes.m_materialDiffuse[1][0], params, 4*sizeof(float) );
05066   }
05067 #else
05068   _GLMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, params );
05069 #endif
05070 }
05071
05073
05075 inline  void  GLMaterialDiffuse( GLenum face, const GLfloat *params )
05076 {
05077 #if defined( GL_CACHING )
05078   switch( face )
05079   {
05080     case GL_BACK :
05081       GLMaterialDiffuseBack( params );
05082       break;
05083     case GL_FRONT :
05084       GLMaterialDiffuseFront( params );
05085       break;
05086     case GL_FRONT_AND_BACK :
05087       GLMaterialDiffuseFrontAndBack( params );
05088       break;
05089     default :
05090       NVSG_ASSERT( false );
05091       break;
05092   }
05093 #else
05094   GLMaterialfv( face, GL_DIFFUSE, params );
05095 #endif
05096 }
05097
05099
05101 inline  void  GLMaterialEmissionBack( const GLfloat *params )
05102 {
05103 #if defined( GL_CACHING )
05104   GLContext * ctx = glContext();
05105   if ( !equal4fv( &ctx->m_lightingAttributes.m_materialEmission[0][0], params ) )
05106   {
05107 # if !defined(NDEBUG)
05108     GLfloat p[4];
05109     GLGetMaterialfv( GL_BACK, GL_EMISSION, p );
05110     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialEmission[0][0], p ) );
05111 # endif
05112 #endif
05113     _GLMaterialfv( GL_BACK, GL_EMISSION, params );
05114 #if defined( GL_CACHING )
05115     memcpy( &ctx->m_lightingAttributes.m_materialEmission[0][0], params, 4*sizeof(float) );
05116   }
05117 #endif
05118 }
05119
05121
05123 inline  void  GLMaterialEmissionFront( const GLfloat *params )
05124 {
05125 #if defined( GL_CACHING )
05126   GLContext * ctx = glContext();
05127   if ( !equal4fv( &ctx->m_lightingAttributes.m_materialEmission[1][0], params ) )
05128   {
05129 # if !defined(NDEBUG)
05130     GLfloat p[4];
05131     glGetMaterialfv( GL_FRONT, GL_EMISSION, p );
05132     NVSG_ASSERT( equal4fv(& ctx->m_lightingAttributes.m_materialEmission[1][0], p ) );
05133 # endif
05134 #endif
05135     _GLMaterialfv( GL_FRONT, GL_EMISSION, params );
05136 #if defined( GL_CACHING )
05137     memcpy( &ctx->m_lightingAttributes.m_materialEmission[1][0], params, 4*sizeof(float) );
05138   }
05139 #endif
05140 }
05141
05143
05145 inline  void  GLMaterialEmissionFrontAndBack( const GLfloat *params )
05146 {
05147 #if defined( GL_CACHING )
05148   GLContext * ctx = glContext();
05149   if (  !equal4fv( &ctx->m_lightingAttributes.m_materialEmission[0][0], params )
05150      || !equal4fv( &ctx->m_lightingAttributes.m_materialEmission[1][0], params ) )
05151   {
05152 # if !defined(NDEBUG)
05153     GLfloat p0[4], p1[4];
05154     glGetMaterialfv( GL_BACK, GL_EMISSION, p0 );
05155     glGetMaterialfv( GL_FRONT, GL_EMISSION, p1 );
05156     NVSG_ASSERT(    equal4fv( &ctx->m_lightingAttributes.m_materialEmission[0][0], p0 )
05157                 &&  equal4fv( &ctx->m_lightingAttributes.m_materialEmission[1][0], p1 ) );
05158 # endif
05159 #endif
05160     _GLMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, params );
05161 #if defined( GL_CACHING )
05162     memcpy( &ctx->m_lightingAttributes.m_materialEmission[0][0], params, 4*sizeof(float) );
05163     memcpy( &ctx->m_lightingAttributes.m_materialEmission[1][0], params, 4*sizeof(float) );
05164   }
05165 #endif
05166 }
05167
05169
05171 inline  void  GLMaterialEmission( GLenum face, const GLfloat *params )
05172 {
05173 #if defined( GL_CACHING )
05174   switch( face )
05175   {
05176     case GL_BACK :
05177       GLMaterialEmissionBack( params );
05178       break;
05179     case GL_FRONT :
05180       GLMaterialEmissionFront( params );
05181       break;
05182     case GL_FRONT_AND_BACK :
05183       GLMaterialEmissionFrontAndBack( params );
05184       break;
05185     default :
05186       NVSG_ASSERT( false );
05187       break;
05188   }
05189 #else
05190   GLMaterialfv( face, GL_EMISSION, params );
05191 #endif
05192 }
05193
05195
05197 inline  void  GLMaterialSpecularBack( const GLfloat *params )
05198 {
05199 #if defined( GL_CACHING )
05200   GLContext * ctx = glContext();
05201   if ( !equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[0][0], params ) )
05202   {
05203 # if !defined(NDEBUG)
05204     GLfloat p[4];
05205     glGetMaterialfv( GL_BACK, GL_SPECULAR, p );
05206     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[0][0], p ) );
05207 # endif
05208 #endif
05209     _GLMaterialfv( GL_BACK, GL_SPECULAR, params );
05210 #if defined( GL_CACHING )
05211     memcpy( &ctx->m_lightingAttributes.m_materialSpecular[0][0], params, 4*sizeof(float) );
05212   }
05213 #endif
05214 }
05215
05217
05219 inline  void  GLMaterialSpecularFront( const GLfloat *params )
05220 {
05221 #if defined( GL_CACHING )
05222   GLContext * ctx = glContext();
05223   if ( !equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[1][0], params ) )
05224   {
05225 # if !defined(NDEBUG)
05226     GLfloat p[4];
05227     glGetMaterialfv( GL_FRONT, GL_SPECULAR, p );
05228     NVSG_ASSERT( equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[1][0], p ) );
05229 # endif
05230 #endif
05231     _GLMaterialfv( GL_FRONT, GL_SPECULAR, params );
05232 #if defined( GL_CACHING )
05233     memcpy( &ctx->m_lightingAttributes.m_materialSpecular[1][0], params, 4*sizeof(float) );
05234   }
05235 #endif
05236 }
05237
05239
05241 inline  void  GLMaterialSpecularFrontAndBack( const GLfloat *params )
05242 {
05243 #if defined( GL_CACHING )
05244   GLContext * ctx = glContext();
05245   if (  !equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[0][0], params )
05246      || !equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[1][0], params ) )
05247   {
05248 # if !defined(NDEBUG)
05249     GLfloat p0[4], p1[4];
05250     glGetMaterialfv( GL_BACK, GL_SPECULAR, p0 );
05251     glGetMaterialfv( GL_FRONT, GL_SPECULAR, p1 );
05252     NVSG_ASSERT(    equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[0][0], p0 )
05253                 &&  equal4fv( &ctx->m_lightingAttributes.m_materialSpecular[1][0], p1 ) );
05254 # endif
05255 #endif
05256     _GLMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, params );
05257 #if defined( GL_CACHING )
05258     memcpy( &ctx->m_lightingAttributes.m_materialSpecular[0][0], params, 4*sizeof(float) );
05259     memcpy( &ctx->m_lightingAttributes.m_materialSpecular[1][0], params, 4*sizeof(float) );
05260   }
05261 #endif
05262 }
05263
05265
05267 inline  void  GLMaterialSpecular( GLenum face, const GLfloat *params )
05268 {
05269 #if defined( GL_CACHING )
05270   switch( face )
05271   {
05272     case GL_BACK :
05273       GLMaterialSpecularBack( params );
05274       break;
05275     case GL_FRONT :
05276       GLMaterialSpecularFront( params );
05277       break;
05278     case GL_FRONT_AND_BACK :
05279       GLMaterialSpecularFrontAndBack( params );
05280       break;
05281     default :
05282       NVSG_ASSERT( false );
05283       break;
05284   }
05285 #else
05286   GLMaterialfv( face, GL_SPECULAR, params );
05287 #endif
05288 }
05289
05291
05292 inline  void  GLMaterialf( GLenum face, GLenum pname, GLfloat param )
05293 {
05294 #if defined( GL_CACHING )
05295   switch( pname )
05296   {
05297     case GL_SHININESS :
05298       GLMaterialShininess( face, param );
05299       break;
05300     default :
05301       _GLMaterialf( face, pname, param );
05302       break;
05303   }
05304 #else
05305   _GLMaterialf( face, pname, param );
05306 #endif
05307 }
05308
05310
05311 inline  void  GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
05312 {
05313 #if defined( GL_CACHING )
05314   switch( pname )
05315   {
05316     case GL_AMBIENT :
05317       GLMaterialAmbient( face, params );
05318       break;
05319     case GL_DIFFUSE :
05320       GLMaterialDiffuse( face, params );
05321       break;
05322     case GL_EMISSION :
05323       GLMaterialEmission( face, params );
05324       break;
05325     case GL_SPECULAR :
05326       GLMaterialSpecular( face, params );
05327       break;
05328     case GL_SHININESS :
05329       GLMaterialShininess( face, params[0] );
05330       break;
05331     default :
05332       _GLMaterialfv( face, pname, params );
05333       break;
05334   }
05335 #else
05336   _GLMaterialfv( face, pname, params );
05337 #endif
05338 }
05339
05341
05342 inline  void  GLMateriali( GLenum face, GLenum pname, GLint param )
05343 {
05344 #if defined( GL_CACHING )
05345   switch( pname )
05346   {
05347     case GL_SHININESS :
05348       GLMaterialShininess( face, (GLfloat)param );
05349       break;
05350     default :
05351       _GLMateriali( face, pname, param );
05352       break;
05353   }
05354 #else
05355   _GLMateriali( face, pname, param );
05356 #endif
05357 }
05358
05360
05361 inline  void  GLMaterialiv( GLenum face, GLenum pname, const GLint *params )
05362 {
05363 #if defined( GL_CACHING )
05364   GLfloat fParams[4];
05365   switch( pname )
05366   {
05367     case GL_AMBIENT :
05368       GLintToGLfloat( params, fParams );
05369       GLMaterialAmbient( face, fParams );
05370       break;
05371     case GL_DIFFUSE :
05372       GLintToGLfloat( params, fParams );
05373       GLMaterialDiffuse( face, fParams );
05374       break;
05375     case GL_EMISSION :
05376       GLintToGLfloat( params, fParams );
05377       GLMaterialEmission( face, fParams );
05378       break;
05379     case GL_SPECULAR :
05380       GLintToGLfloat( params, fParams );
05381       GLMaterialSpecular( face, fParams );
05382       break;
05383     case GL_SHININESS :
05384       GLMaterialShininess( face, (GLfloat)params[0] );
05385       break;
05386     default :
05387       _GLMaterialiv( face, pname, params );
05388       break;
05389   }
05390 #else
05391   _GLMaterialiv( face, pname, params );
05392 #endif
05393 }
05394
05396
05397 inline  void  GLMatrixMode( GLenum mode )
05398 {
05399 #if defined( GL_CACHING )
05400   GLContext * ctx = glContext();
05401   if ( ctx->m_transformAttributes.m_matrixMode != mode )
05402 #endif
05403   {
05404     NVSG_GL_STATS_MATRIX_MODE( mode );
05405     glMatrixMode( mode );
05406     ASSERT_GL_NO_ERROR;
05407 #if defined( GL_CACHING )
05408     ctx->m_transformAttributes.m_matrixMode = mode;
05409 #endif
05410   }
05411 }
05412
05414
05415 inline  void  GLMultiTexCoord2f( GLenum texture, GLfloat tx, GLfloat ty )
05416 {
05417   NVSG_GL_STATS_FCT_COUNT();
05418   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultiTexCoord2f );
05419   glContext()->m_glFunctions->glMultiTexCoord2f( texture, tx, ty );
05420   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05421 }
05422
05424
05425 inline  void  GLMultMatrixd( const GLdouble *m )
05426 {
05427   NVSG_GL_STATS_MULT_MATRIXD( m );
05428 #if defined( GL_CACHING )
05429   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
05430   { // note: we have a texture matrix stack per unit
05431     _GLUpdateActiveTexture();
05432   }
05433 #endif
05434   glMultMatrixd( m );
05435   ASSERT_GL_NO_ERROR;
05436 }
05437
05439
05440 inline  void  GLMultMatrixf( const GLfloat *m )
05441 {
05442   NVSG_GL_STATS_MULT_MATRIXF( m );
05443 #if defined( GL_CACHING )
05444   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
05445   { // note: we have a texture matrix stack per unit
05446     _GLUpdateActiveTexture();
05447   }
05448 #endif
05449   glMultMatrixf( m );
05450   ASSERT_GL_NO_ERROR;
05451 }
05452
05454
05455 inline  void  GLMultTransposeMatrixd( const GLdouble *m )
05456 {
05457   NVSG_GL_STATS_MULT_MATRIXD( m );
05458 #if defined( GL_CACHING )
05459   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
05460   { // note: we have a texture matrix stack per unit
05461     _GLUpdateActiveTexture();
05462   }
05463 #endif
05464   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultTransposeMatrixd );
05465   glContext()->m_glFunctions->glMultTransposeMatrixd( m );
05466   ASSERT_GL_NO_ERROR;
05467 }
05468
05470
05471 inline  void  GLMultTransposeMatrixf( const GLfloat *m )
05472 {
05473   NVSG_GL_STATS_MULT_MATRIXF( m );
05474 #if defined( GL_CACHING )
05475   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
05476   { // note: we have a texture matrix stack per unit
05477     _GLUpdateActiveTexture();
05478   }
05479 #endif
05480   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glMultTransposeMatrixf );
05481   glContext()->m_glFunctions->glMultTransposeMatrixf( m );
05482   ASSERT_GL_NO_ERROR;
05483 }
05484
05486
05487 inline  void  GLNewList( GLuint list, GLenum mode )
05488 {
05489   NVSG_GL_STATS_NEW_LIST( list, mode );
05490   glNewList( list, mode );
05491   ASSERT_GL_NO_ERROR;
05492 }
05493
05495
05496 inline  void  GLNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
05497 {
05498   NVSG_GL_STATS_FCT_COUNT();
05499   glNormal3b( nx, ny, nz );
05500   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05501 }
05502
05504
05505 inline  void  GLNormal3bv( const GLbyte *v )
05506 {
05507   NVSG_GL_STATS_FCT_COUNT();
05508   glNormal3bv( v );
05509   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05510 }
05511
05513
05514 inline  void  GLNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
05515 {
05516   NVSG_GL_STATS_FCT_COUNT();
05517   glNormal3d( nx, ny, nz );
05518   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05519 }
05520
05522
05523 inline  void  GLNormal3dv( const GLdouble *v )
05524 {
05525   NVSG_GL_STATS_FCT_COUNT();
05526   glNormal3dv( v );
05527   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05528 }
05529
05531
05532 inline  void  GLNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
05533 {
05534   NVSG_GL_STATS_FCT_COUNT();
05535   glNormal3f( nx, ny, nz );
05536   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05537 }
05538
05540
05541 inline  void  GLNormal3fv( const GLfloat *v )
05542 {
05543   NVSG_GL_STATS_FCT_COUNT();
05544   glNormal3fv( v );
05545   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05546 }
05547
05549
05550 inline  void  GLNormal3i( GLint nx, GLint ny, GLint nz )
05551 {
05552   NVSG_GL_STATS_FCT_COUNT();
05553   glNormal3i( nx, ny, nz );
05554   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05555 }
05556
05558
05559 inline  void  GLNormal3iv( const GLint *v )
05560 {
05561   NVSG_GL_STATS_FCT_COUNT();
05562   glNormal3iv( v );
05563   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05564 }
05565
05567
05568 inline  void  GLNormal3s( GLshort nx, GLshort ny, GLshort nz )
05569 {
05570   NVSG_GL_STATS_FCT_COUNT();
05571   glNormal3s( nx, ny, nz );
05572   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05573 }
05574
05576
05577 inline  void  GLNormal3sv( const GLshort *v )
05578 {
05579   NVSG_GL_STATS_FCT_COUNT();
05580   glNormal3sv( v );
05581   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
05582 }
05583
05585
05586 inline  void  GLNormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
05587 {
05588 #if defined(GL_CACHING)
05589   GLContext::VertexArrayParameters parameters( 3, type, stride, pointer );
05590   GLContext * ctx = glContext();
05591   if ( ctx->m_vertexArrayAttributes.m_normalArrayParams != parameters )
05592 #endif
05593   {
05594     NVSG_GL_STATS_NORMAL_POINTER( type, stride, pointer );
05595     glNormalPointer( type, stride, pointer );
05596     ASSERT_GL_NO_ERROR;
05597 #if defined(GL_CACHING)
05598     ctx->m_vertexArrayAttributes.m_normalArrayParams = parameters;
05599 #endif
05600   }
05601 }
05602
05604
05605 inline  void  GLOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
05606 {
05607   NVSG_GL_STATS_ORTHO( left, right, bottom, top, zNear, zFar );
05608   glOrtho( left, right, bottom, top, zNear, zFar );
05609   ASSERT_GL_NO_ERROR;
05610 }
05611
05613
05614 inline  void  GLPassThrough( GLfloat token )
05615 {
05616   NVSG_GL_STATS_FCT_COUNT();
05617   glPassThrough( token );
05618   ASSERT_GL_NO_ERROR;
05619 }
05620
05622
05623 inline  void  GLPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
05624 {
05625   NVSG_GL_STATS_FCT_COUNT();
05626   glPixelMapfv( map, mapsize, values );
05627   ASSERT_GL_NO_ERROR;
05628 }
05629
05631
05632 inline  void  GLPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
05633 {
05634   NVSG_GL_STATS_FCT_COUNT();
05635   glPixelMapuiv( map, mapsize, values );
05636   ASSERT_GL_NO_ERROR;
05637 }
05638
05640
05641 inline  void  GLPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
05642 {
05643   NVSG_GL_STATS_FCT_COUNT();
05644   glPixelMapusv( map, mapsize, values );
05645   ASSERT_GL_NO_ERROR;
05646 }
05647
05649
05650 inline  void  GLPixelStoref( GLenum pname, GLfloat param )
05651 {
05652   NVSG_GL_STATS_FCT_COUNT();
05653   glPixelStoref( pname, param );
05654   ASSERT_GL_NO_ERROR;
05655 }
05656
05658
05659 inline  void  GLPixelStorei( GLenum pname, GLint param )
05660 {
05661   NVSG_GL_STATS_FCT_COUNT();
05662   glPixelStorei( pname, param );
05663   ASSERT_GL_NO_ERROR;
05664 }
05665
05667
05668 inline  void  GLPixelTransferf( GLenum pname, GLfloat param )
05669 {
05670   NVSG_GL_STATS_FCT_COUNT();
05671   glPixelTransferf( pname, param );
05672   ASSERT_GL_NO_ERROR;
05673 }
05674
05676
05677 inline  void  GLPixelTransferi( GLenum pname, GLint param )
05678 {
05679   NVSG_GL_STATS_FCT_COUNT();
05680   glPixelTransferi( pname, param );
05681   ASSERT_GL_NO_ERROR;
05682 }
05683
05685
05686 inline  void  GLPixelZoom( GLfloat xfactor, GLfloat yfactor )
05687 {
05688   NVSG_GL_STATS_FCT_COUNT();
05689   glPixelZoom( xfactor, yfactor );
05690   ASSERT_GL_NO_ERROR;
05691 }
05692
05694
05695 inline  void  GLPointSize( GLfloat size )
05696 {
05697 #if defined( GL_CACHING )
05698   GLContext * ctx = glContext();
05699   if ( !equalf(ctx->m_pointAttributes.m_size, size) )
05700   {
05701 # if !defined(NDEBUG)
05702     GLfloat f;
05703     glGetFloatv( GL_POINT_SIZE, &f );
05704     NVSG_ASSERT( equalf(ctx->m_pointAttributes.m_size, f) );
05705 # endif
05706 #endif
05707     NVSG_GL_STATS_POINT_SIZE( size );
05708     glPointSize( size );
05709     ASSERT_GL_NO_ERROR;
05710 #if defined( GL_CACHING )
05711     ctx->m_pointAttributes.m_size = size;
05712   }
05713 #endif
05714 }
05715
05717
05719 inline  void  GLPolygonModeBack( GLenum mode )
05720 {
05721   GLContext * ctx = glContext();
05722 #if defined( GL_CACHING )
05723   if ( ctx->m_polygonAttributes.m_rasterMode[1] != mode )
05724 #endif
05725   {
05726     if ( ! ctx->m_locks.m_polygonMode )
05727     {
05728 #if defined( GL_CACHING) && !defined( NDEBUG )
05729       GLint p[2];
05730       glGetIntegerv( GL_POLYGON_MODE, p );
05731       NVSG_ASSERT( ctx->m_polygonAttributes.m_rasterMode[1] == p[1] );
05732 #endif
05733       _GLPolygonMode( GL_BACK, mode );
05734 #if defined( GL_CACHING )
05735       ctx->m_polygonAttributes.m_rasterMode[1] = mode;
05736 #endif
05737     }
05738   }
05739 }
05740
05742
05744 inline  void  GLPolygonModeFront( GLenum mode )
05745 {
05746   GLContext * ctx = glContext();
05747 #if defined( GL_CACHING )
05748   if ( ctx->m_polygonAttributes.m_rasterMode[0] != mode )
05749 #endif
05750   {
05751     if ( ! ctx->m_locks.m_polygonMode )
05752     {
05753 #if defined( GL_CACHING ) && !defined( NDEBUG )
05754       GLint p[2];
05755       glGetIntegerv( GL_POLYGON_MODE, p );
05756       NVSG_ASSERT( ctx->m_polygonAttributes.m_rasterMode[0] == p[0] );
05757 #endif
05758       _GLPolygonMode( GL_FRONT, mode );
05759 #if defined( GL_CACHING )
05760       ctx->m_polygonAttributes.m_rasterMode[0] = mode;
05761 #endif
05762     }
05763   }
05764 }
05765
05767
05769 inline  void  GLPolygonModeFrontAndBack( GLenum mode )
05770 {
05771   GLContext * ctx = glContext();
05772 #if defined( GL_CACHING )
05773   if (    ( ctx->m_polygonAttributes.m_rasterMode[0] != mode )
05774       ||  ( ctx->m_polygonAttributes.m_rasterMode[1] != mode ) )
05775 #endif
05776   {
05777     if ( ! ctx->m_locks.m_polygonMode )
05778     {
05779 #if defined( GL_CACHING ) && !defined( NDEBUG )
05780       GLint p[2];
05781       glGetIntegerv( GL_POLYGON_MODE, p );
05782       NVSG_ASSERT(    ( ctx->m_polygonAttributes.m_rasterMode[0] == p[0] )
05783                   &&  ( ctx->m_polygonAttributes.m_rasterMode[1] == p[1] ) );
05784 #endif
05785       _GLPolygonMode( GL_FRONT_AND_BACK, mode );
05786 #if defined( GL_CACHING )
05787       ctx->m_polygonAttributes.m_rasterMode[0] = mode;
05788       ctx->m_polygonAttributes.m_rasterMode[1] = mode;
05789 #endif
05790     }
05791   }
05792 }
05793
05795
05796 inline  void  GLPolygonMode( GLenum face, GLenum mode )
05797 {
05798 #if defined( GL_CACHING )
05799   switch( face )
05800   {
05801     case GL_BACK :
05802       GLPolygonModeBack( mode );
05803       break;
05804     case GL_FRONT :
05805       GLPolygonModeFront( mode );
05806       break;
05807     case GL_FRONT_AND_BACK :
05808       GLPolygonModeFrontAndBack( mode );
05809       break;
05810     default :
05811       NVSG_ASSERT( false );
05812       break;
05813   }
05814 #else
05815   _GLPolygonMode( face, mode );
05816 #endif
05817 }
05818
05819 inline void GLPolygonModeLock( GLenum face, GLenum mode )
05820 {
05821   NVSG_ASSERT( ! glContext()->m_locks.m_polygonMode );
05822   GLPolygonMode( face, mode );
05823   glContext()->m_locks.m_polygonMode = true;
05824 }
05825
05826 inline void GLPolygonModeUnlock( GLenum face, GLenum mode )
05827 {
05828   glContext()->m_locks.m_polygonMode = false;
05829   GLPolygonMode( face, mode );
05830 }
05831
05833
05834 inline  void  GLPolygonOffset( GLfloat factor, GLfloat units )
05835 {
05836 #if defined( GL_CACHING )
05837   GLContext * ctx = glContext();
05838   if (  !equalf(ctx->m_polygonAttributes.m_offsetFactor, factor)
05839      || !equalf(ctx->m_polygonAttributes.m_offsetBias, units) )
05840 #endif
05841   {
05842     NVSG_GL_STATS_POLYGON_OFFSET( factor, units );
05843     glPolygonOffset( factor, units );
05844     ASSERT_GL_NO_ERROR;
05845 #if defined( GL_CACHING )
05846     ctx->m_polygonAttributes.m_offsetFactor  = factor;
05847     ctx->m_polygonAttributes.m_offsetBias   = units;
05848 #endif
05849   }
05850 }
05851
05853
05854 inline  void  GLPolygonStipple( const GLubyte *mask )
05855 {
05856   NVSG_GL_STATS_FCT_COUNT();
05857   glPolygonStipple( mask );
05858   ASSERT_GL_NO_ERROR;
05859 }
05860
05862
05866 inline  void  GLPopAttrib( void )
05867 {
05868   NVSG_GL_STATS_POP_ATTRIB();
05869   glPopAttrib();
05870   ASSERT_GL_NO_ERROR;
05871 #if defined( GL_CACHING )
05872   GLContext * ctx = glContext();
05873   GLbitfield mask = (GLbitfield)ctx->m_pushMasks.top();
05874   if ( mask == GL_ALL_ATTRIB_BITS )
05875   {
05876     ctx->m_colorBufferAttributes = ctx->m_colorBufferAttributesStack.top();
05877     ctx->m_colorBufferAttributesStack.pop();
05878     ctx->m_colorBufferEnableAttributes = ctx->m_colorBufferEnableAttributesStack.top();
05879     ctx->m_colorBufferEnableAttributesStack.pop();
05880     ctx->m_depthBufferAttributes = ctx->m_depthBufferAttributesStack.top();
05881     ctx->m_depthBufferAttributesStack.pop();
05882     ctx->m_depthBufferEnableAttributes = ctx->m_depthBufferEnableAttributesStack.top();
05883     ctx->m_depthBufferEnableAttributesStack.pop();
05884     ctx->m_lightingAttributes = ctx->m_lightingAttributesStack.top();
05885     ctx->m_lightingAttributesStack.pop();
05886     ctx->m_lightingEnableAttributes = ctx->m_lightingEnableAttributesStack.top();
05887     ctx->m_lightingEnableAttributesStack.pop();
05888     ctx->m_lineAttributes = ctx->m_lineAttributesStack.top();
05889     ctx->m_lineAttributesStack.pop();
05890     ctx->m_lineEnableAttributes = ctx->m_lineEnableAttributesStack.top();
05891     ctx->m_lineEnableAttributesStack.pop();
05892     ctx->m_pointAttributes = ctx->m_pointAttributesStack.top();
05893     ctx->m_pointAttributesStack.pop();
05894     ctx->m_pointEnableAttributes = ctx->m_pointEnableAttributesStack.top();
05895     ctx->m_pointEnableAttributesStack.pop();
05896     ctx->m_polygonAttributes = ctx->m_polygonAttributesStack.top();
05897     ctx->m_polygonAttributesStack.pop();
05898     ctx->m_polygonEnableAttributes = ctx->m_polygonEnableAttributesStack.top();
05899     ctx->m_polygonEnableAttributesStack.pop();
05900     ctx->m_textureAttributes = ctx->m_textureAttributesStack.top();
05901     ctx->m_textureAttributesStack.pop();
05902     ctx->m_textureEnableAttributes = ctx->m_textureEnableAttributesStack.top();
05903     ctx->m_textureEnableAttributesStack.pop();
05904     ctx->m_transformAttributes = ctx->m_transformAttributesStack.top();
05905     ctx->m_transformAttributesStack.pop();
05906     ctx->m_transformEnableAttributes = ctx->m_transformEnableAttributesStack.top();
05907     ctx->m_transformEnableAttributesStack.pop();
05908   }
05909   else
05910   {
05911     if ( mask & GL_COLOR_BUFFER_BIT )
05912     {
05913       ctx->m_colorBufferAttributes = ctx->m_colorBufferAttributesStack.top();
05914       ctx->m_colorBufferAttributesStack.pop();
05915     }
05916     if ( mask & GL_DEPTH_BUFFER_BIT )
05917     {
05918       ctx->m_depthBufferAttributes = ctx->m_depthBufferAttributesStack.top();
05919       ctx->m_depthBufferAttributesStack.pop();
05920     }
05921     if ( mask & ( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT ) )
05922     {
05923       ctx->m_colorBufferEnableAttributes = ctx->m_colorBufferEnableAttributesStack.top();
05924       ctx->m_colorBufferEnableAttributesStack.pop();
05925     }
05926     if ( mask & ( GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT ) )
05927     {
05928       ctx->m_depthBufferEnableAttributes = ctx->m_depthBufferEnableAttributesStack.top();
05929       ctx->m_depthBufferEnableAttributesStack.pop();
05930     }
05931     if ( mask & ( GL_ENABLE_BIT | GL_LIGHTING_BIT ) )
05932     {
05933       ctx->m_lightingEnableAttributes = ctx->m_lightingEnableAttributesStack.top();
05934       ctx->m_lightingEnableAttributesStack.pop();
05935     }
05936     if ( mask & ( GL_ENABLE_BIT | GL_LINE_BIT ) )
05937     {
05938       ctx->m_lineEnableAttributes = ctx->m_lineEnableAttributesStack.top();
05939       ctx->m_lineEnableAttributesStack.pop();
05940     }
05941     if ( mask & ( GL_ENABLE_BIT | GL_POINT_BIT ) )
05942     {
05943       ctx->m_pointEnableAttributes = ctx->m_pointEnableAttributesStack.top();
05944       ctx->m_pointEnableAttributesStack.pop();
05945     }
05946     if ( mask & ( GL_ENABLE_BIT | GL_POLYGON_BIT ) )
05947     {
05948       ctx->m_polygonEnableAttributes = ctx->m_polygonEnableAttributesStack.top();
05949       ctx->m_polygonEnableAttributesStack.pop();
05950     }
05951     if ( mask & ( GL_ENABLE_BIT | GL_TEXTURE_BIT ) )
05952     {
05953       ctx->m_textureEnableAttributes = ctx->m_textureEnableAttributesStack.top();
05954       ctx->m_textureEnableAttributesStack.pop();
05955     }
05956     if ( mask & ( GL_ENABLE_BIT | GL_TRANSFORM_BIT ) )
05957     {
05958       ctx->m_transformEnableAttributes = ctx->m_transformEnableAttributesStack.top();
05959       ctx->m_transformEnableAttributesStack.pop();
05960     }
05961     if ( mask & GL_LIGHTING_BIT )
05962     {
05963       ctx->m_lightingAttributes = ctx->m_lightingAttributesStack.top();
05964       ctx->m_lightingAttributesStack.pop();
05965     }
05966     if ( mask & GL_LINE_BIT )
05967     {
05968       ctx->m_lineAttributes = ctx->m_lineAttributesStack.top();
05969       ctx->m_lineAttributesStack.pop();
05970     }
05971     if ( mask & GL_POINT_BIT )
05972     {
05973       ctx->m_pointAttributes = ctx->m_pointAttributesStack.top();
05974       ctx->m_pointAttributesStack.pop();
05975     }
05976     if ( mask & GL_POLYGON_BIT )
05977     {
05978       ctx->m_polygonAttributes = ctx->m_polygonAttributesStack.top();
05979       ctx->m_polygonAttributesStack.pop();
05980     }
05981     if ( mask & GL_TEXTURE_BIT )
05982     {
05983       ctx->m_textureAttributes = ctx->m_textureAttributesStack.top();
05984       ctx->m_textureAttributesStack.pop();
05985     }
05986     if ( mask & GL_TRANSFORM_BIT )
05987     {
05988       ctx->m_transformAttributes = ctx->m_transformAttributesStack.top();
05989       ctx->m_transformAttributesStack.pop();
05990     }
05991   }
05992   ctx->m_pushMasks.pop();
05993 #endif
05994 }
05995
05997
06001 inline  void  GLPopClientAttrib( void )
06002 {
06003   NVSG_GL_STATS_FCT_COUNT();
06004   glPopClientAttrib();
06005   ASSERT_GL_NO_ERROR;
06006 #if defined( GL_CACHING )
06007   GLContext * ctx = glContext();
06008   GLbitfield mask = (GLbitfield)ctx->m_clientPushMasks.top();
06009   if ( mask & GL_CLIENT_VERTEX_ARRAY_BIT )
06010   {
06011     ctx->m_vertexArrayAttributes = ctx->m_vertexArrayAttributesStack.top();
06012     ctx->m_vertexArrayAttributesStack.pop();
06013   }
06014   ctx->m_clientPushMasks.pop();
06015 #endif
06016 }
06017
06019
06020 inline  void  GLPopMatrix( void )
06021 {
06022   NVSG_GL_STATS_POP_MATRIX();
06023 #if defined( GL_CACHING )
06024   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
06025   { // note: we have a texture matrix stack per unit
06026     _GLUpdateActiveTexture();
06027   }
06028 #endif
06029   glPopMatrix();
06030   ASSERT_GL_NO_ERROR;
06031 }
06032
06034
06035 inline  void  GLPopName( void )
06036 {
06037   NVSG_GL_STATS_FCT_COUNT();
06038   glPopName();
06039   ASSERT_GL_NO_ERROR;
06040 }
06041
06043
06044 inline  void  GLPrimitiveRestartIndex( GLuint index )
06045 {
06046   GLContext * ctx = glContext();
06047 #if defined( GL_CACHING )
06048   if ( ctx->m_vertexArrayAttributes.m_primitiveRestartIndex != index )
06049 #endif
06050   {
06051     NVSG_GL_STATS_PRIMITIVE_RESTART_INDEX( index );
06052     ctx->m_glFunctions->glPrimitiveRestartIndexNV( index );
06053     ASSERT_GL_NO_ERROR;
06054 #if defined( GL_CACHING )
06055     ctx->m_vertexArrayAttributes.m_primitiveRestartIndex = index;
06056 #endif
06057   }
06058 }
06059
06061
06062 inline  void  GLPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities )
06063 {
06064   NVSG_GL_STATS_FCT_COUNT();
06065   glPrioritizeTextures( n, textures, priorities );
06066   ASSERT_GL_NO_ERROR;
06067 }
06068
06070
06071 inline  void  GLProgramNamedParameter4f( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
06072 {
06073   NVSG_GL_STATS_FCT_COUNT();
06074   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glProgramNamedParameter4fNV );
06075   glContext()->m_glFunctions->glProgramNamedParameter4fNV( id, len, name, x, y, z, w );
06076   ASSERT_GL_NO_ERROR;
06077 }
06078
06080
06084 inline  void  GLPushAttrib( GLbitfield mask )
06085 {
06086   NVSG_GL_STATS_PUSH_ATTRIB( mask );
06087   glPushAttrib( mask );
06088   ASSERT_GL_NO_ERROR;
06089 #if defined( GL_CACHING )
06090   GLContext * ctx = glContext();
06091   ctx->m_pushMasks.push( mask );
06092   if ( mask == GL_ALL_ATTRIB_BITS )
06093   {
06094     ctx->m_colorBufferAttributesStack.push( ctx->m_colorBufferAttributes );
06095     ctx->m_colorBufferEnableAttributesStack.push( ctx->m_colorBufferEnableAttributes );
06096     ctx->m_depthBufferAttributesStack.push( ctx->m_depthBufferAttributes );
06097     ctx->m_depthBufferEnableAttributesStack.push( ctx->m_depthBufferEnableAttributes );
06098     ctx->m_lightingAttributesStack.push( ctx->m_lightingAttributes );
06099     ctx->m_lightingEnableAttributesStack.push( ctx->m_lightingEnableAttributes );
06100     ctx->m_lineAttributesStack.push( ctx->m_lineAttributes );
06101     ctx->m_lineEnableAttributesStack.push( ctx->m_lineEnableAttributes );
06102     ctx->m_pointAttributesStack.push( ctx->m_pointAttributes );
06103     ctx->m_pointEnableAttributesStack.push( ctx->m_pointEnableAttributes );
06104     ctx->m_polygonAttributesStack.push( ctx->m_polygonAttributes );
06105     ctx->m_polygonEnableAttributesStack.push( ctx->m_polygonEnableAttributes );
06106     ctx->m_textureAttributesStack.push( ctx->m_textureAttributes );
06107     ctx->m_textureEnableAttributesStack.push( ctx->m_textureEnableAttributes );
06108     ctx->m_transformAttributesStack.push( ctx->m_transformAttributes );
06109     ctx->m_transformEnableAttributesStack.push( ctx->m_transformEnableAttributes );
06110   }
06111   else
06112   {
06113     if ( mask & GL_COLOR_BUFFER_BIT )
06114     {
06115       ctx->m_colorBufferAttributesStack.push( ctx->m_colorBufferAttributes );
06116     }
06117     if ( mask & GL_DEPTH_BUFFER_BIT )
06118     {
06119       ctx->m_depthBufferAttributesStack.push( ctx->m_depthBufferAttributes );
06120     }
06121     if ( mask & ( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT ) )
06122     {
06123       ctx->m_colorBufferEnableAttributesStack.push( ctx->m_colorBufferEnableAttributes );
06124     }
06125     if ( mask & ( GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT ) )
06126     {
06127       ctx->m_depthBufferEnableAttributesStack.push( ctx->m_depthBufferEnableAttributes );
06128     }
06129     if ( mask & ( GL_ENABLE_BIT | GL_LIGHTING_BIT ) )
06130     {
06131       ctx->m_lightingEnableAttributesStack.push( ctx->m_lightingEnableAttributes );
06132     }
06133     if ( mask & ( GL_ENABLE_BIT | GL_LINE_BIT ) )
06134     {
06135       ctx->m_lineEnableAttributesStack.push( ctx->m_lineEnableAttributes );
06136     }
06137     if ( mask & ( GL_ENABLE_BIT | GL_POINT_BIT ) )
06138     {
06139       ctx->m_pointEnableAttributesStack.push( ctx->m_pointEnableAttributes );
06140     }
06141     if ( mask & ( GL_ENABLE_BIT | GL_POLYGON_BIT ) )
06142     {
06143       ctx->m_polygonEnableAttributesStack.push( ctx->m_polygonEnableAttributes );
06144     }
06145     if ( mask & ( GL_ENABLE_BIT | GL_TEXTURE_BIT ) )
06146     {
06147       ctx->m_textureEnableAttributesStack.push( ctx->m_textureEnableAttributes );
06148     }
06149     if ( mask & ( GL_ENABLE_BIT | GL_TRANSFORM_BIT ) )
06150     {
06151       ctx->m_transformEnableAttributesStack.push( ctx->m_transformEnableAttributes );
06152     }
06153     if ( mask & GL_LIGHTING_BIT )
06154     {
06155       ctx->m_lightingAttributesStack.push( ctx->m_lightingAttributes );
06156     }
06157     if ( mask & GL_LINE_BIT )
06158     {
06159       ctx->m_lineAttributesStack.push( ctx->m_lineAttributes );
06160     }
06161     if ( mask & GL_POINT_BIT )
06162     {
06163       ctx->m_pointAttributesStack.push( ctx->m_pointAttributes );
06164     }
06165     if ( mask & GL_POLYGON_BIT )
06166     {
06167       ctx->m_polygonAttributesStack.push( ctx->m_polygonAttributes );
06168     }
06169     if ( mask & GL_TEXTURE_BIT )
06170     {
06171       ctx->m_textureAttributesStack.push( ctx->m_textureAttributes );
06172     }
06173     if ( mask & GL_TRANSFORM_BIT )
06174     {
06175       ctx->m_transformAttributesStack.push( ctx->m_transformAttributes );
06176     }
06177   }
06178 #endif
06179 }
06180
06182
06186 inline  void  GLPushClientAttrib( GLbitfield mask )
06187 {
06188   NVSG_GL_STATS_FCT_COUNT();
06189   glPushClientAttrib( mask );
06190   ASSERT_GL_NO_ERROR;
06191 #if defined( GL_CACHING )
06192   GLContext * ctx = glContext();
06193   ctx->m_clientPushMasks.push( mask );
06194   if ( mask & GL_CLIENT_VERTEX_ARRAY_BIT )
06195   {
06196     ctx->m_vertexArrayAttributesStack.push( ctx->m_vertexArrayAttributes );
06197   }
06198 #endif
06199 }
06200
06202
06203 inline  void  GLPushMatrix( void )
06204 {
06205   NVSG_GL_STATS_PUSH_MATRIX();
06206 #if defined( GL_CACHING )
06207   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
06208   { // note: we have a texture matrix stack per unit
06209     _GLUpdateActiveTexture();
06210   }
06211 #endif
06212   glPushMatrix();
06213   ASSERT_GL_NO_ERROR;
06214 }
06215
06217
06218 inline  void  GLPushName( GLuint name )
06219 {
06220   NVSG_GL_STATS_FCT_COUNT();
06221   glPushName( name );
06222   ASSERT_GL_NO_ERROR;
06223 }
06224
06226
06227 inline  void  GLRasterPos2d( GLdouble x, GLdouble y )
06228 {
06229   NVSG_GL_STATS_FCT_COUNT();
06230   glRasterPos2d( x, y );
06231   ASSERT_GL_NO_ERROR;
06232 }
06233
06235
06236 inline  void  GLRasterPos2f( GLfloat x, GLfloat y )
06237 {
06238   NVSG_GL_STATS_FCT_COUNT();
06239   glRasterPos2f( x, y );
06240   ASSERT_GL_NO_ERROR;
06241 }
06242
06244
06245 inline  void  GLRasterPos2i( GLint x, GLint y )
06246 {
06247   NVSG_GL_STATS_FCT_COUNT();
06248   glRasterPos2i( x, y );
06249   ASSERT_GL_NO_ERROR;
06250 }
06251
06253
06254 inline  void  GLRasterPos2s( GLshort x, GLshort y )
06255 {
06256   NVSG_GL_STATS_FCT_COUNT();
06257   glRasterPos2s( x, y );
06258   ASSERT_GL_NO_ERROR;
06259 }
06260
06262
06263 inline  void  GLRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
06264 {
06265   NVSG_GL_STATS_FCT_COUNT();
06266   glRasterPos3d( x, y, z );
06267   ASSERT_GL_NO_ERROR;
06268 }
06269
06271
06272 inline  void  GLRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
06273 {
06274   NVSG_GL_STATS_FCT_COUNT();
06275   glRasterPos3f( x, y, z );
06276   ASSERT_GL_NO_ERROR;
06277 }
06278
06280
06281 inline  void  GLRasterPos3i( GLint x, GLint y, GLint z )
06282 {
06283   NVSG_GL_STATS_FCT_COUNT();
06284   glRasterPos3i( x, y, z );
06285   ASSERT_GL_NO_ERROR;
06286 }
06287
06289
06290 inline  void  GLRasterPos3s( GLshort x, GLshort y, GLshort z )
06291 {
06292   NVSG_GL_STATS_FCT_COUNT();
06293   glRasterPos3s( x, y, z );
06294   ASSERT_GL_NO_ERROR;
06295 }
06296
06298
06299 inline  void  GLRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
06300 {
06301   NVSG_GL_STATS_FCT_COUNT();
06302   glRasterPos4d( x, y, z, w );
06303   ASSERT_GL_NO_ERROR;
06304 }
06305
06307
06308 inline  void  GLRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
06309 {
06310   NVSG_GL_STATS_FCT_COUNT();
06311   glRasterPos4f( x, y, z, w );
06312   ASSERT_GL_NO_ERROR;
06313 }
06314
06316
06317 inline  void  GLRasterPos4i( GLint x, GLint y, GLint z, GLint w )
06318 {
06319   NVSG_GL_STATS_FCT_COUNT();
06320   glRasterPos4i( x, y, z, w );
06321   ASSERT_GL_NO_ERROR;
06322 }
06323
06325
06326 inline  void  GLRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
06327 {
06328   NVSG_GL_STATS_FCT_COUNT();
06329   glRasterPos4s( x, y, z, w );
06330   ASSERT_GL_NO_ERROR;
06331 }
06332
06334
06335 inline  void  GLReadBuffer( GLenum mode )
06336 {
06337   NVSG_GL_STATS_FCT_COUNT();
06338   glReadBuffer( mode );
06339   ASSERT_GL_NO_ERROR;
06340 }
06341
06343
06344 inline  void  GLReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
06345 {
06346   NVSG_GL_STATS_FCT_COUNT();
06347   glReadPixels( x, y, width, height, format, type, pixels );
06348   ASSERT_GL_NO_ERROR;
06349 }
06350
06352
06353 inline  void  GLRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
06354 {
06355   NVSG_GL_STATS_FCT_COUNT();
06356   glRectd( x1, y1, x2, y2 );
06357   ASSERT_GL_NO_ERROR;
06358 }
06359
06361
06362 inline  void  GLRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
06363 {
06364   NVSG_GL_STATS_FCT_COUNT();
06365   glRectf( x1, y1, x2, y2 );
06366   ASSERT_GL_NO_ERROR;
06367 }
06368
06370
06371 inline  void  GLRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
06372 {
06373   NVSG_GL_STATS_FCT_COUNT();
06374   glRecti( x1, y1, x2, y2 );
06375   ASSERT_GL_NO_ERROR;
06376 }
06377
06379
06380 inline  void  GLRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
06381 {
06382   NVSG_GL_STATS_FCT_COUNT();
06383   glRects( x1, y1, x2, y2 );
06384   ASSERT_GL_NO_ERROR;
06385 }
06386
06388
06389 inline  void  GLRenderMode( GLenum mode )
06390 {
06391   NVSG_GL_STATS_FCT_COUNT();
06392   glRenderMode( mode );
06393   ASSERT_GL_NO_ERROR;
06394 }
06395
06397
06398 inline  void  GLRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
06399 {
06400   NVSG_GL_STATS_ROTATED( angle, x, y, z );
06401 #if defined( GL_CACHING )
06402   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
06403   { // note: we have a texture matrix stack per unit
06404     _GLUpdateActiveTexture();
06405   }
06406 #endif
06407   glRotated( angle, x, y, z );
06408   ASSERT_GL_NO_ERROR;
06409 }
06410
06412
06413 inline  void  GLRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
06414 {
06415   NVSG_GL_STATS_ROTATEF( angle, x, y, z );
06416 #if defined( GL_CACHING )
06417   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
06418   { // note: we have a texture matrix stack per unit
06419     _GLUpdateActiveTexture();
06420   }
06421 #endif
06422   glRotatef( angle, x, y, z );
06423   ASSERT_GL_NO_ERROR;
06424 }
06425
06427
06428 inline  void  GLScaled( GLdouble x, GLdouble y, GLdouble z )
06429 {
06430   NVSG_GL_STATS_SCALED( x, y, z );
06431 #if defined( GL_CACHING )
06432   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
06433   { // note: we have a texture matrix stack per unit
06434     _GLUpdateActiveTexture();
06435   }
06436 #endif
06437   glScaled( x, y, z );
06438   ASSERT_GL_NO_ERROR;
06439 }
06440
06442
06443 inline  void  GLScalef( GLfloat x, GLfloat y, GLfloat z )
06444 {
06445   NVSG_GL_STATS_SCALEF( x, y, z );
06446 #if defined( GL_CACHING )
06447   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
06448   { // note: we have a texture matrix stack per unit
06449     _GLUpdateActiveTexture();
06450   }
06451 #endif
06452   glScalef( x, y, z );
06453   ASSERT_GL_NO_ERROR;
06454 }
06455
06457
06458 inline  void  GLScissor( GLint x, GLint y, GLsizei width, GLsizei height )
06459 {
06460   NVSG_GL_STATS_FCT_COUNT();
06461   glScissor( x, y, width, height );
06462   ASSERT_GL_NO_ERROR;
06463 }
06464
06466
06467 inline  void  GLSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
06468 {
06469 #if defined( GL_CACHING )
06470   GLContext::VertexArrayParameters parameters( size, type, stride, pointer );
06471   if ( glContext()->m_vertexArrayAttributes.m_secondaryColorArrayParams != parameters )
06472 #endif
06473   {
06474     NVSG_GL_STATS_FCT_COUNT();
06475     glContext()->m_glFunctions->glSecondaryColorPointer( size, type, stride, pointer );
06476     ASSERT_GL_NO_ERROR;
06477 #if defined( GL_CACHING )
06478     glContext()->m_vertexArrayAttributes.m_secondaryColorArrayParams = parameters;
06479 #endif
06480   }
06481 }
06482
06484
06485 inline  void  GLSelectBuffer( GLsizei size, GLuint *buffer )
06486 {
06487   NVSG_GL_STATS_FCT_COUNT();
06488   glSelectBuffer( size, buffer );
06489   ASSERT_GL_NO_ERROR;
06490 }
06491
06493
06494 inline  void  GLSetWindowStereoMode( GLboolean displayMode )
06495 {
06496   NVSG_GL_STATS_FCT_COUNT();
06497   NVSG_ASSERT( glContext()->m_glFunctions );
06498   if ( glContext()->m_glFunctions->glSetWindowStereoModeNV )
06499   {
06500     glContext()->m_glFunctions->glSetWindowStereoModeNV( displayMode );
06501     ASSERT_GL_NO_ERROR;
06502   }
06503 }
06504
06506
06507 inline  void  GLShadeModel( GLenum mode )
06508 {
06509   NVSG_GL_STATS_FCT_COUNT();
06510   glShadeModel( mode );
06511   ASSERT_GL_NO_ERROR;
06512 }
06513
06515
06516 inline  void  GLStencilFunc( GLenum func, GLint ref, GLuint mask )
06517 {
06518   NVSG_GL_STATS_FCT_COUNT();
06519   glStencilFunc( func, ref, mask );
06520   ASSERT_GL_NO_ERROR;
06521 }
06522
06524
06525 inline  void  GLStencilMask( GLuint mask )
06526 {
06527   NVSG_GL_STATS_FCT_COUNT();
06528   glStencilMask( mask );
06529   ASSERT_GL_NO_ERROR;
06530 }
06531
06533
06534 inline  void  GLStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
06535 {
06536   NVSG_GL_STATS_FCT_COUNT();
06537   glStencilOp( fail, zfail, zpass );
06538   ASSERT_GL_NO_ERROR;
06539 }
06540
06542
06543 inline  void  GLTexCoord1d( GLdouble s )
06544 {
06545   NVSG_GL_STATS_FCT_COUNT();
06546   glTexCoord1d( s );
06547   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06548 }
06549
06551
06552 inline  void  GLTexCoord1f( GLfloat s )
06553 {
06554   NVSG_GL_STATS_FCT_COUNT();
06555   glTexCoord1f( s );
06556   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06557 }
06558
06560
06561 inline  void  GLTexCoord1i( GLint s )
06562 {
06563   NVSG_GL_STATS_FCT_COUNT();
06564   glTexCoord1i( s );
06565   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06566 }
06567
06569
06570 inline  void  GLTexCoord1s( GLshort s )
06571 {
06572   NVSG_GL_STATS_FCT_COUNT();
06573   glTexCoord1s( s );
06574   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06575 }
06576
06578
06579 inline  void  GLTexCoord2d( GLdouble s, GLdouble t )
06580 {
06581   NVSG_GL_STATS_FCT_COUNT();
06582   glTexCoord2d( s, t );
06583   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06584 }
06585
06587
06588 inline  void  GLTexCoord2f( GLfloat s, GLfloat t )
06589 {
06590   NVSG_GL_STATS_FCT_COUNT();
06591   glTexCoord2f( s, t );
06592   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06593 }
06594
06596
06597 inline  void  GLTexCoord2fv( const GLfloat *v )
06598 {
06599   NVSG_GL_STATS_FCT_COUNT();
06600   glTexCoord2fv( v );
06601   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06602 }
06603
06605
06606 inline  void  GLTexCoord2i( GLint s, GLint t )
06607 {
06608   NVSG_GL_STATS_FCT_COUNT();
06609   glTexCoord2i( s, t );
06610   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06611 }
06612
06614
06615 inline  void  GLTexCoord2s( GLshort s, GLshort t )
06616 {
06617   NVSG_GL_STATS_FCT_COUNT();
06618   glTexCoord2s( s, t );
06619   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06620 }
06621
06623
06624 inline  void  GLTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
06625 {
06626   NVSG_GL_STATS_FCT_COUNT();
06627   glTexCoord3d( s, t, r );
06628   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06629 }
06630
06632
06633 inline  void  GLTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
06634 {
06635   NVSG_GL_STATS_FCT_COUNT();
06636   glTexCoord3f( s, t, r );
06637   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06638 }
06639
06641
06642 inline  void  GLTexCoord3i( GLint s, GLint t, GLint r )
06643 {
06644   NVSG_GL_STATS_FCT_COUNT();
06645   glTexCoord3i( s, t, r );
06646   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06647 }
06648
06650
06651 inline  void  GLTexCoord3s( GLshort s, GLshort t, GLshort r )
06652 {
06653   NVSG_GL_STATS_FCT_COUNT();
06654   glTexCoord3s( s, t, r );
06655   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06656 }
06657
06659
06660 inline  void  GLTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
06661 {
06662   NVSG_GL_STATS_FCT_COUNT();
06663   glTexCoord4d( s, t, r, q );
06664   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06665 }
06666
06668
06669 inline  void  GLTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
06670 {
06671   NVSG_GL_STATS_FCT_COUNT();
06672   glTexCoord4f( s, t, r, q );
06673   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06674 }
06675
06677
06678 inline  void  GLTexCoord4i( GLint s, GLint t, GLint r, GLint q )
06679 {
06680   NVSG_GL_STATS_FCT_COUNT();
06681   glTexCoord4i( s, t, r, q );
06682   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06683 }
06684
06686
06687 inline  void  GLTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
06688 {
06689   NVSG_GL_STATS_FCT_COUNT();
06690   glTexCoord4s( s, t, r, q );
06691   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
06692 }
06693
06695
06696 inline  void  GLTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
06697 {
06698 #if defined( GL_CACHING )
06699   _GLUpdateClientActiveTexture();
06700   NVSG_ASSERT(glContext()->m_vertexArrayAttributes.m_clientTextureActive<8);
06701   size_t i = glContext()->m_vertexArrayAttributes.m_clientTextureActive;
06702   GLContext::VertexArrayParameters parameters( size, type, stride, pointer );
06703   if ( glContext()->m_vertexArrayAttributes.m_textureCoordArrayParams[i] != parameters )
06704 #endif
06705   {
06706     NVSG_GL_STATS_TEX_COORD_POINTER( size, type, stride, pointer );
06707     glTexCoordPointer( size, type, stride, pointer );
06708     ASSERT_GL_NO_ERROR;
06709 #if defined( GL_CACHING )
06710     glContext()->m_vertexArrayAttributes.m_textureCoordArrayParams[i] = parameters;
06711 #endif
06712   }
06713 }
06714
06716
06718 inline  void  GLTextureEnvColor( const GLfloat * params )
06719 {
06720 #if defined( GL_CACHING )
06721   if ( !equal4fv( &glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envColor[0], params ) )
06722   {
06723     _GLUpdateActiveTexture();
06724 # if !defined(NDEBUG)
06725     GLfloat tmp[4];
06726     glGetTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, tmp );
06727     NVSG_ASSERT( equal4fv(&glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envColor[0], params ) );
06728 # endif
06729 #endif
06730     _GLTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params );
06731 #if defined( GL_CACHING )
06732     memcpy( &glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envColor[0], params, 4*sizeof(float) );
06733   }
06734 #endif
06735 }
06736
06738
06740 inline  void  GLTextureEnvMode( GLint param )
06741 {
06742 #if defined( GL_CACHING )
06743   if ( glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envMode != param )
06744   {
06745     _GLUpdateActiveTexture();
06746 # if !defined(NDEBUG)
06747     GLint tem;
06748     glGetTexEnviv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &tem );
06749     NVSG_ASSERT( glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envMode == tem );
06750 # endif
06751 #endif
06752     _GLTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, param );
06753 #if defined( GL_CACHING )
06754     glContext()->m_textureAttributes.m_unit[glContext()->m_textureAttributes.m_toActivate].m_envMode = param;
06755   }
06756 #endif
06757 }
06758
06760
06761 inline  void  GLTexEnvf( GLenum target, GLenum pname, GLfloat param )
06762 {
06763   NVSG_ASSERT( ( target == GL_TEXTURE_ENV ) );
06764 #if defined( GL_CACHING )
06765   switch( pname )
06766   {
06767     case GL_TEXTURE_ENV_MODE :
06768       GLTextureEnvMode( (GLint)param );
06769       break;
06770     default :
06771       _GLUpdateActiveTexture();
06772       _GLTexEnvf( target, pname, param );
06773       break;
06774   }
06775 #else
06776   _GLTexEnvf( target, pname, param );
06777 #endif
06778 }
06779
06781
06782 inline  void  GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
06783 {
06784   NVSG_ASSERT( ( target == GL_TEXTURE_ENV ) );
06785 #if defined( GL_CACHING )
06786   switch( pname )
06787   {
06788     case GL_TEXTURE_ENV_COLOR :
06789       GLTextureEnvColor( params );
06790       break;
06791     case GL_TEXTURE_ENV_MODE :
06792       GLTextureEnvMode( (GLint)params[0] );
06793       break;
06794     default :
06795       _GLUpdateActiveTexture();
06796       _GLTexEnvfv( target, pname, params );
06797       break;
06798   }
06799 #else
06800   _GLTexEnvfv( target, pname, params );
06801 #endif
06802 }
06803
06805
06806 inline  void  GLTexEnvi( GLenum target, GLenum pname, GLint param )
06807 {
06808   NVSG_ASSERT( ( target == GL_TEXTURE_ENV ) );
06809 #if defined( GL_CACHING )
06810   switch( pname )
06811   {
06812     case GL_TEXTURE_ENV_MODE :
06813       GLTextureEnvMode( param );
06814       break;
06815     default :
06816       _GLUpdateActiveTexture();
06817       _GLTexEnvi( target, pname, param );
06818       break;
06819   }
06820 #else
06821   _GLTexEnvi( target, pname, param );
06822 #endif
06823 }
06824
06826
06827 inline  void  GLTexEnviv( GLenum target, GLenum pname, const GLint *params )
06828 {
06829   NVSG_ASSERT( ( target == GL_TEXTURE_ENV ) );
06830 #if defined( GL_CACHING )
06831   switch( pname )
06832   {
06833     case GL_TEXTURE_ENV_MODE :
06834       GLTextureEnvMode( params[0] );
06835       break;
06836     default :
06837       _GLUpdateActiveTexture();
06838       _GLTexEnviv( target, pname, params );
06839       break;
06840   }
06841 #else
06842   _GLTexEnviv( target, pname, params );
06843 #endif
06844 }
06845
06847
06848 inline  void  GLTexGend( GLenum coord, GLenum pname, GLdouble param )
06849 {
06850 #if defined(GL_CACHING)
06851   _GLUpdateActiveTexture();
06852 #endif
06853   NVSG_GL_STATS_FCT_COUNT();
06854   glTexGend( coord, pname, param );
06855   ASSERT_GL_NO_ERROR;
06856 }
06857
06859
06860 inline  void  GLTexGenf( GLenum coord, GLenum pname, GLfloat param )
06861 {
06862 #if defined(GL_CACHING)
06863   _GLUpdateActiveTexture();
06864 #endif
06865   NVSG_GL_STATS_FCT_COUNT();
06866   glTexGenf( coord, pname, param );
06867   ASSERT_GL_NO_ERROR;
06868 }
06869
06871
06872 inline  void  GLTexGenfv( GLenum coord, GLenum pname, const GLfloat *param )
06873 {
06874 #if defined(GL_CACHING)
06875   _GLUpdateActiveTexture();
06876 #endif
06877   NVSG_GL_STATS_FCT_COUNT();
06878   glTexGenfv( coord, pname, param );
06879   ASSERT_GL_NO_ERROR;
06880 }
06881
06883
06884 inline  void  GLTexGeni( GLenum coord, GLenum pname, GLint param )
06885 {
06886 #if defined(GL_CACHING)
06887   _GLUpdateActiveTexture();
06888 #endif
06889   NVSG_GL_STATS_FCT_COUNT();
06890   glTexGeni( coord, pname, param );
06891   ASSERT_GL_NO_ERROR;
06892 }
06893
06895
06896 inline  void  GLTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
06897 {
06898 #if defined(GL_CACHING)
06899   _GLUpdateActiveTexture();
06900 #endif
06901   NVSG_GL_STATS_FCT_COUNT();
06902   glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
06903   ASSERT_GL_NO_ERROR;
06904 }
06905
06907
06908 inline  void  GLTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border
06909                           , GLenum format, GLenum type, const GLvoid *pixels )
06910 {
06911 #if defined(GL_CACHING)
06912   _GLUpdateActiveTexture();
06913 #endif
06914   NVSG_GL_STATS_TEX_IMAGE2D( target, level, internalformat, width, height, border, format, type, pixels );
06915   glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
06916   ASSERT_GL_NO_ERROR;
06917 }
06918
06920
06922 inline  void  GLTexImage3D( GLenum target, int level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type, const void* pixels)
06923 {
06924 #if defined(GL_CACHING)
06925   _GLUpdateActiveTexture();
06926 #endif
06927   NVSG_GL_STATS_FCT_COUNT();
06928   NVSG_ASSERT( glContext()->m_glFunctions && glContext()->m_glFunctions->glTexImage3D );
06929   glContext()->m_glFunctions->glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
06930   ASSERT_GL_NO_ERROR;
06931 }
06932
06934
06936 inline  void  GLTextureBorderColor( GLenum target, const GLfloat *params )
06937 {
06938 #if defined( GL_CACHING )
06939   _GLUpdateActiveTexture();
06940 #endif
06941   _GLTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, params );
06942 }
06943
06945
06947 inline  void  GLTextureMagFilter( GLenum target, GLint param )
06948 {
06949 #if defined( GL_CACHING )
06950   _GLUpdateActiveTexture();
06951 #endif
06952   _GLTexParameteri( target, GL_TEXTURE_MAG_FILTER, param );
06953 }
06954
06956
06958 inline  void  GLTextureMinFilter( GLenum target, GLint param )
06959 {
06960 #if defined( GL_CACHING )
06961   _GLUpdateActiveTexture();
06962 #endif
06963   _GLTexParameteri( target, GL_TEXTURE_MIN_FILTER, param );
06964 }
06965
06967
06969 inline  void  GLTextureWrapR( GLenum target, GLint param )
06970 {
06971 #if defined( GL_CACHING )
06972   _GLUpdateActiveTexture();
06973 #endif
06974   _GLTexParameteri( target, GL_TEXTURE_WRAP_R, param );
06975 }
06976
06978
06980 inline  void  GLTextureWrapS( GLenum target, GLint param )
06981 {
06982 #if defined( GL_CACHING )
06983   _GLUpdateActiveTexture();
06984 #endif
06985   _GLTexParameteri( target, GL_TEXTURE_WRAP_S, param );
06986 }
06987
06989
06991 inline  void  GLTextureWrapT( GLenum target, GLint param )
06992 {
06993 #if defined( GL_CACHING )
06994   _GLUpdateActiveTexture();
06995 #endif
06996   _GLTexParameteri( target, GL_TEXTURE_WRAP_T, param );
06997 }
06998
07000
07001 inline  void  GLTexParameterf( GLenum target, GLenum pname, GLfloat param )
07002 {
07003 #if defined( GL_CACHING )
07004   switch( pname )
07005   {
07006     case GL_TEXTURE_BORDER_COLOR :
07007       NVSG_ASSERT( false );
07008       break;
07009     case GL_TEXTURE_MAG_FILTER :
07010       GLTextureMagFilter( target, (GLint)param );
07011       break;
07012     case GL_TEXTURE_MIN_FILTER :
07013       GLTextureMinFilter( target, (GLint)param );
07014       break;
07015     case GL_TEXTURE_WRAP_R :
07016       GLTextureWrapR( target, (GLint)param );
07017       break;
07018     case GL_TEXTURE_WRAP_S :
07019       GLTextureWrapS( target, (GLint)param );
07020       break;
07021     case GL_TEXTURE_WRAP_T :
07022       GLTextureWrapT( target, (GLint)param );
07023       break;
07024     default :
07025       _GLUpdateActiveTexture();
07026       _GLTexParameterf( target, pname, param );
07027       break;
07028   }
07029 #else
07030   _GLTexParameterf( target, pname, param );
07031 #endif
07032 }
07033
07035
07036 inline  void  GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
07037 {
07038 #if defined( GL_CACHING )
07039   switch( pname )
07040   {
07041     case GL_TEXTURE_BORDER_COLOR :
07042       GLTextureBorderColor( target, params );
07043       break;
07044     case GL_TEXTURE_MAG_FILTER :
07045       GLTextureMagFilter( target, (GLint)params[0] );
07046       break;
07047     case GL_TEXTURE_MIN_FILTER :
07048       GLTextureMinFilter( target, (GLint)params[0] );
07049       break;
07050     case GL_TEXTURE_WRAP_R :
07051       GLTextureWrapR( target, (GLint)params[0] );
07052       break;
07053     case GL_TEXTURE_WRAP_S :
07054       GLTextureWrapS( target, (GLint)params[0] );
07055       break;
07056     case GL_TEXTURE_WRAP_T :
07057       GLTextureWrapT( target, (GLint)params[0] );
07058       break;
07059     default :
07060       _GLUpdateActiveTexture();
07061       _GLTexParameterfv( target, pname, params );
07062       break;
07063   }
07064 #else
07065   _GLTexParameterfv( target, pname, params );
07066 #endif
07067 }
07068
07070
07071 inline  void  GLTexParameteri( GLenum target, GLenum pname, GLint param )
07072 {
07073 #if defined( GL_CACHING )
07074   switch( pname )
07075   {
07076     case GL_TEXTURE_BORDER_COLOR :
07077       NVSG_ASSERT( false );
07078       break;
07079     case GL_TEXTURE_MAG_FILTER :
07080       GLTextureMagFilter( target, param );
07081       break;
07082     case GL_TEXTURE_MIN_FILTER :
07083       GLTextureMinFilter( target, param );
07084       break;
07085     case GL_TEXTURE_WRAP_R :
07086       GLTextureWrapR( target, param );
07087       break;
07088     case GL_TEXTURE_WRAP_S :
07089       GLTextureWrapS( target, param );
07090       break;
07091     case GL_TEXTURE_WRAP_T :
07092       GLTextureWrapT( target, param );
07093       break;
07094     default :
07095       _GLUpdateActiveTexture();
07096       _GLTexParameteri( target, pname, param );
07097       break;
07098   }
07099 #else
07100   _GLTexParameteri( target, pname, param );
07101 #endif
07102 }
07103
07105
07106 inline  void  GLTexParameteriv( GLenum target, GLenum pname, const GLint *params )
07107 {
07108 #if defined( GL_CACHING )
07109   switch( pname )
07110   {
07111     case GL_TEXTURE_BORDER_COLOR :
07112       {
07113         GLfloat fParams[4];
07114         GLintToGLfloat( params, fParams );
07115         GLTextureBorderColor( target, fParams );
07116       }
07117       break;
07118     case GL_TEXTURE_MAG_FILTER :
07119       GLTextureMagFilter( target, params[0] );
07120       break;
07121     case GL_TEXTURE_MIN_FILTER :
07122       GLTextureMinFilter( target, params[0] );
07123       break;
07124     case GL_TEXTURE_WRAP_R :
07125       GLTextureWrapR( target, params[0] );
07126       break;
07127     case GL_TEXTURE_WRAP_S :
07128       GLTextureWrapS( target, params[0] );
07129       break;
07130     case GL_TEXTURE_WRAP_T :
07131       GLTextureWrapT( target, params[0] );
07132       break;
07133     default :
07134       _GLUpdateActiveTexture();
07135       _GLTexParameteriv( target, pname, params );
07136       break;
07137   }
07138 #else
07139   _GLTexParameteriv( target, pname, params );
07140 #endif
07141 }
07142
07144
07145 inline  void  GLTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
07146 {
07147 #if defined(GL_CACHING)
07148   _GLUpdateActiveTexture();
07149 #endif
07150   NVSG_GL_STATS_FCT_COUNT();
07151   glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
07152   ASSERT_GL_NO_ERROR;
07153 }
07154
07156
07157 inline  void  GLTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
07158 {
07159 #if defined(GL_CACHING)
07160   _GLUpdateActiveTexture();
07161 #endif
07162   NVSG_GL_STATS_FCT_COUNT();
07163   glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
07164   ASSERT_GL_NO_ERROR;
07165 }
07166
07168
07169 inline  void  GLTranslated( GLdouble x, GLdouble y, GLdouble z )
07170 {
07171   NVSG_GL_STATS_TRANSLATED( x, y, z );
07172 #if defined( GL_CACHING )
07173   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
07174   { // note: we have a texture matrix stack per unit
07175     _GLUpdateActiveTexture();
07176   }
07177 #endif
07178   glTranslated( x, y, z );
07179   ASSERT_GL_NO_ERROR;
07180 }
07181
07183
07184 inline  void  GLTranslatef( GLfloat x, GLfloat y, GLfloat z )
07185 {
07186   NVSG_GL_STATS_TRANSLATEF( x, y, z );
07187 #if defined( GL_CACHING )
07188   if ( GL_TEXTURE == glContext()->m_transformAttributes.m_matrixMode )
07189   { // note: we have a texture matrix stack per unit
07190     _GLUpdateActiveTexture();
07191   }
07192 #endif
07193   glTranslatef( x, y, z );
07194   ASSERT_GL_NO_ERROR;
07195 }
07196
07198
07199 inline  void  GLVertex2d( GLdouble x, GLdouble y )
07200 {
07201   NVSG_GL_STATS_FCT_COUNT();
07202   glVertex2d( x, y );
07203   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07204 }
07205
07207
07208 inline  void  GLVertex2f( GLfloat x, GLfloat y )
07209 {
07210   NVSG_GL_STATS_FCT_COUNT();
07211   glVertex2f( x, y );
07212   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07213 }
07214
07216
07217 inline  void  GLVertex2i( GLint x, GLint y )
07218 {
07219   NVSG_GL_STATS_FCT_COUNT();
07220   glVertex2i( x, y );
07221   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07222 }
07223
07225
07226 inline  void  GLVertex2s( GLshort x, GLshort y )
07227 {
07228   NVSG_GL_STATS_FCT_COUNT();
07229   glVertex2s( x, y );
07230   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07231 }
07232
07234
07235 inline  void  GLVertex3d( GLdouble x, GLdouble y, GLdouble z )
07236 {
07237   NVSG_GL_STATS_FCT_COUNT();
07238   glVertex3d( x, y, z );
07239   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07240 }
07241
07243
07244 inline  void  GLVertex3f( GLfloat x, GLfloat y, GLfloat z )
07245 {
07246   NVSG_GL_STATS_FCT_COUNT();
07247   glVertex3f( x, y, z );
07248   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07249 }
07250
07252
07253 inline  void  GLVertex3fv( const GLfloat *v )
07254 {
07255   NVSG_GL_STATS_FCT_COUNT();
07256   glVertex3fv( v );
07257   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07258 }
07259
07261
07262 inline  void  GLVertex3i( GLint x, GLint y, GLint z )
07263 {
07264   NVSG_GL_STATS_FCT_COUNT();
07265   glVertex3i( x, y, z );
07266   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07267 }
07268
07270
07271 inline  void  GLVertex3s( GLshort x, GLshort y, GLshort z )
07272 {
07273   NVSG_GL_STATS_FCT_COUNT();
07274   glVertex3s( x, y, z );
07275   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07276 }
07277
07279
07280 inline  void  GLVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
07281 {
07282   NVSG_GL_STATS_FCT_COUNT();
07283   glVertex4d( x, y, z, w );
07284   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07285 }
07286
07288
07289 inline  void  GLVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
07290 {
07291   NVSG_GL_STATS_FCT_COUNT();
07292   glVertex4f( x, y, z, w );
07293   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07294 }
07295
07297
07298 inline  void  GLVertex4i( GLint x, GLint y, GLint z, GLint w )
07299 {
07300   NVSG_GL_STATS_FCT_COUNT();
07301   glVertex4i( x, y, z, w );
07302   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07303 }
07304
07306
07307 inline  void  GLVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
07308 {
07309   NVSG_GL_STATS_FCT_COUNT();
07310   glVertex4s( x, y, z, w );
07311   ASSERT_GL_NO_ERROR_IN_BEGIN_END;
07312 }
07313
07315
07316 inline  void  GLVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer )
07317 {
07318 #if defined( GL_CACHING )
07319   GLContext::VertexArrayParameters parameters( size, type, stride, pointer );
07320   if ( glContext()->m_vertexArrayAttributes.m_vertexArrayParams != parameters )
07321 #endif
07322   {
07323     NVSG_GL_STATS_VERTEX_POINTER( size, type, stride, pointer );
07324     glVertexPointer( size, type, stride, pointer );
07325     ASSERT_GL_NO_ERROR;
07326 #if defined( GL_CACHING )
07327     glContext()->m_vertexArrayAttributes.m_vertexArrayParams = parameters;
07328 #endif
07329   }
07330 }
07331
07333
07334 inline  void  GLViewport( GLint x, GLint y, GLsizei width, GLsizei height )
07335 {
07336   NVSG_GL_STATS_VIEWPORT( x, y, width, height );
07337   glViewport( x, y, width, height );
07338   ASSERT_GL_NO_ERROR;
07339 }
07340
07341 #if defined(_WIN32)
07342
07343
07344 inline  BOOL  WGLBindTexImage( HPBUFFERARB hPbuffer, int iBuffer )
07345 {
07346   NVSG_GL_STATS_FCT_COUNT();
07347   NVSG_ASSERT( glContext()->m_glFunctions->wglBindTexImageARB );
07348   return glContext()->m_glFunctions->wglBindTexImageARB( hPbuffer, iBuffer );
07349 }
07350
07352
07353 inline  BOOL  WGLChoosePixelFormat( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats )
07354 {
07355   NVSG_GL_STATS_FCT_COUNT();
07356   NVSG_ASSERT( glContext()->m_glFunctions->wglChoosePixelFormatARB );
07357   return glContext()->m_glFunctions->wglChoosePixelFormatARB( hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats );
07358 }
07359
07361
07364 inline  HGLRC WGLCreateContext( HDC hdc )
07365 {
07366   HGLRC hglrc = wglCreateContext( hdc );
07367   WGLAttachContext(hdc, hglrc);
07368   return hglrc;
07369 }
07370
07372
07375 inline  HPBUFFERARB WGLCreatePbuffer( HDC hdc, int pixelFormat, int width, int height, const int *attribList )
07376 {
07377   NVSG_GL_STATS_FCT_COUNT();
07378   NVSG_ASSERT( wglGetCurrentContext() != NULL );
07379   NVSG_ASSERT( glContext()->m_glFunctions->wglCreatePbufferARB );
07380   HPBUFFERARB hPbuffer = glContext()->m_glFunctions->wglCreatePbufferARB( hdc, pixelFormat, width, height, attribList );
07381   return( hPbuffer );
07382 }
07383
07385
07389 inline  BOOL  WGLDeleteContext( HGLRC hglrc )
07390 {
07391   NVSG_GL_STATS_FCT_COUNT();
07392   WGLDetachContext(hglrc);
07393   return wglDeleteContext(hglrc);
07394 }
07395
07397
07398 inline  BOOL  WGLDestroyPbuffer( HPBUFFERARB hPbuffer )
07399 {
07400   NVSG_GL_STATS_FCT_COUNT();
07401   NVSG_ASSERT(glContext()->m_glFunctions->wglDestroyPbufferARB);
07402   return glContext()->m_glFunctions->wglDestroyPbufferARB( hPbuffer );
07403 }
07404
07406
07410 inline  HGLRC  WGLGetCurrentContext(void)
07411 {
07412   // !! NOTE: no NVSG_GL_STATS_FCT_COUNT macro call here, because it relies on a valid glContext !!
07413   ASSERT_GL_CURRENT_CONTEXT_CONFORMITY();
07414   return wglGetCurrentContext();
07415 }
07416
07418
07423 inline  HDC  WGLGetCurrentDC(void)
07424 {
07425   NVSG_GL_STATS_FCT_COUNT();
07426   return wglGetCurrentDC();
07427 }
07428
07430
07431 inline  HDC WGLGetPbufferDC( HPBUFFERARB hPbuffer )
07432 {
07433   NVSG_GL_STATS_FCT_COUNT();
07434   NVSG_ASSERT( glContext()->m_glFunctions->wglGetPbufferDCARB );
07435   return glContext()->m_glFunctions->wglGetPbufferDCARB( hPbuffer );
07436 }
07437
07439
07440 inline  BOOL  WGLQueryPbuffer( HPBUFFERARB hPbuffer, int attribute, int *value )
07441 {
07442   NVSG_GL_STATS_FCT_COUNT();
07443   NVSG_ASSERT( glContext()->m_glFunctions->wglQueryPbufferARB );
07444   return glContext()->m_glFunctions->wglQueryPbufferARB( hPbuffer, attribute, value );
07445 }
07446
07448
07449 inline  int WGLReleasePbufferDC( HPBUFFERARB hPbuffer, HDC hdc )
07450 {
07451   NVSG_GL_STATS_FCT_COUNT();
07452   NVSG_ASSERT( glContext()->m_glFunctions->wglReleasePbufferDCARB );
07453   int i = glContext()->m_glFunctions->wglReleasePbufferDCARB( hPbuffer, hdc );
07454   NVSG_ASSERT( i == 1 );
07455   return( i );
07456 }
07457
07459
07460 inline  BOOL  WGLReleaseTexImage( HPBUFFERARB hPbuffer, int iBuffer )
07461 {
07462   NVSG_GL_STATS_FCT_COUNT();
07463   NVSG_ASSERT( glContext()->m_glFunctions->wglReleaseTexImageARB );
07464   return glContext()->m_glFunctions->wglReleaseTexImageARB( hPbuffer, iBuffer );
07465 }
07466
07468 inline BOOL WGLJoinSwapGroupNV(HDC hDC, GLuint group)
07469 {
07470   NVSG_GL_STATS_FCT_COUNT();
07471   return glContext()->m_glFunctions->wglJoinSwapGroupNV(hDC, group);
07472 }
07473
07475 inline BOOL WGLBindSwapBarrierNV(GLuint group, GLuint barrier)
07476 {
07477   NVSG_GL_STATS_FCT_COUNT();
07478   return glContext()->m_glFunctions->wglBindSwapBarrierNV(group, barrier);
07479 }
07480
07482 inline BOOL WGLQuerySwapGroupNV(HDC hDC, GLuint * group, GLuint * barrier)
07483 {
07484   NVSG_GL_STATS_FCT_COUNT();
07485   return glContext()->m_glFunctions->wglQuerySwapGroupNV(hDC, group, barrier);
07486 }
07487
07489 inline BOOL WGLQueryMaxSwapGroupsNV(HDC hDC, GLuint * maxGroups, GLuint * maxBarriers)
07490 {
07491   NVSG_GL_STATS_FCT_COUNT();
07492   return glContext()->m_glFunctions->wglQueryMaxSwapGroupsNV(hDC, maxGroups, maxBarriers);
07493 }
07494
07496 inline BOOL WGLQueryFrameCountNV(HDC hDC, GLuint * count)
07497 {
07498   NVSG_GL_STATS_FCT_COUNT();
07499   return glContext()->m_glFunctions->wglQueryFrameCountNV(hDC, count);
07500 }
07501
07503 inline BOOL WGLResetFrameCountNV(HDC hDC)
07504 {
07505   NVSG_GL_STATS_FCT_COUNT();
07506   return glContext()->m_glFunctions->wglResetFrameCountNV(hDC);
07507 }
07508 #endif
07509
07510 #if defined(LINUX)
07511
07512 inline GLXContext GLXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
07513 {
07514   GLXContext ctx = glXCreateContext(dpy, vis, shareList, direct);
07515   GLXAttachContext(dpy, ctx);
07516   return ctx;
07517 }
07518
07520 inline void GLXDestroyContext(Display *dpy, GLXContext ctx)
07521 {
07522   NVSG_GL_STATS_FCT_COUNT();
07523   GLXDetachContext(ctx);
07524   return glXDestroyContext(dpy, ctx);
07525 }
07526
07528 inline GLXContext GLXGetCurrentContext()
07529 {
07530   ASSERT_GL_CURRENT_CONTEXT_CONFORMITY();
07531   return glXGetCurrentContext();
07532 }
07533
07535 inline GLXDrawable GLXGetCurrentDrawable()
07536 {
07537   NVSG_GL_STATS_FCT_COUNT();
07538   return glXGetCurrentDrawable();
07539 }
07540
07541 #endif // LINUX
07542
07543 enum
07544 {
07545   GL_INVALID_BUFFER_TARGET = -1
07546   // specialized targets for vertex buffers
07547 , GL_VERTEX_BUFFER_INTERLEAVED_GENERIC = 0
07548 , GL_VERTEX_BUFFER_FIRST = GL_VERTEX_BUFFER_INTERLEAVED_GENERIC
07549 , GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F
07550 , GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F_T2F
07551 , GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F_T2F_TG3F_BN3F
07552 , GL_VERTEX_BUFFER_LAST = GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F_T2F_TG3F_BN3F
07553 , GL_INDEX_BUFFER_GENERIC
07554 , GL_INDEX_BUFFER_FIRST = GL_INDEX_BUFFER_GENERIC
07555 , GL_INDEX_BUFFER_UNSIGNED_SHORT
07556 , GL_INDEX_BUFFER_UNSIGNED_INT
07557 , GL_INDEX_BUFFER_LAST = GL_INDEX_BUFFER_UNSIGNED_INT
07558 , GL_NUM_BUFFER_TARGETS
07559 };
07560
07562
07564 NVSG_API void GLGenVertexBuffer(GLenum target, GLsizeiptr size, GLuint * buffer);
07565
07567
07569 NVSG_API void GLGenIndexBuffer(GLenum target, GLsizeiptr size, GLuint * buffer);
07570
07572
07575 NVSG_API void GLDeleteVertexBuffer(GLuint buffer);
07576
07578
07581 NVSG_API void GLDeleteIndexBuffer(GLuint buffer);
07582
07584
07586 NVSG_API void GLBindVertexBuffer(GLuint buffer);
07587
07589
07591 NVSG_API void GLBindIndexBuffer(GLuint buffer);
07592
07594
07600 NVSG_API void GLUploadBuffers();
07601
07603
07615 NVSG_API GLvoid * GLMapVertexBuffer(GLuint buffer);
07616
07618
07630 NVSG_API GLvoid * GLMapIndexBuffer(GLuint buffer);
07631
07633
07640 NVSG_API GLboolean GLUnmapVertexBuffer(GLuint buffer);
07641
07643
07650 NVSG_API GLboolean GLUnmapIndexBuffer(GLuint buffer);
07651
07653
07656 NVSG_API GLsizeiptr GLGetVertexBufferOffset(GLuint buffer);
07657
07659
07662 NVSG_API GLsizeiptr GLGetIndexBufferOffset(GLuint buffer);
07663
07665
07667 NVSG_API GLboolean GLIsVertexBuffer(GLuint buffer);
07668
07670
07672 NVSG_API GLboolean GLIsIndexBuffer(GLuint buffer);
07673
07675
07678 NVSG_API GLsizeiptr GLGetBaseBufferOffset();
07679
07680 #if !defined(DOXYGEN_IGNORE)
07681 inline void _GLDisable( GLenum cap )
07682 {
07683   NVSG_GL_STATS_STATE( cap, false );
07684   glDisable( cap );
07685   ASSERT_GL_NO_ERROR;
07686 }
07687
07688 inline void _GLDisableClientState( GLenum array )
07689 {
07690   NVSG_GL_STATS_CLIENT_STATE( array, false );
07691   glDisableClientState( array );
07692   ASSERT_GL_NO_ERROR;
07693 }
07694
07695 inline void _GLEnable( GLenum cap )
07696 {
07697   NVSG_GL_STATS_STATE( cap, true );
07698   glEnable( cap );
07699   ASSERT_GL_NO_ERROR;
07700 }
07701
07702 inline void _GLEnableClientState( GLenum array )
07703 {
07704   NVSG_GL_STATS_CLIENT_STATE( array, true );
07705   glEnableClientState( array );
07706   ASSERT_GL_NO_ERROR;
07707 }
07708
07709 inline  void  _GLLightf( GLenum light, GLenum pname, GLfloat param )
07710 {
07711   NVSG_GL_STATS_LIGHTF( light, pname, param );
07712   glLightf( light, pname, param );
07713   ASSERT_GL_NO_ERROR;
07714 }
07715
07716 inline void _GLLightfv( GLenum light, GLenum pname, const GLfloat *params )
07717 {
07718   NVSG_GL_STATS_LIGHTFV( light, pname, params );
07719   glLightfv( light, pname, params );
07720   ASSERT_GL_NO_ERROR;
07721 }
07722
07723 inline void _GLLighti( GLenum light, GLenum pname, GLint param )
07724 {
07725   NVSG_GL_STATS_LIGHTI( light, pname, param );
07726   glLighti( light, pname, param );
07727   ASSERT_GL_NO_ERROR;
07728 }
07729
07730 inline void _GLLightiv( GLenum light, GLenum pname, GLint *params )
07731 {
07732   NVSG_GL_STATS_LIGHTIV( light, pname, params );
07733   glLightiv( light, pname, params );
07734   ASSERT_GL_NO_ERROR;
07735 }
07736
07737 inline void _GLLightModelf( GLenum pname, GLfloat param )
07738 {
07739   NVSG_GL_STATS_LIGHT_MODELF( pname, param );
07740   glLightModelf( pname, param );
07741   ASSERT_GL_NO_ERROR;
07742 }
07743
07744 inline void _GLLightModelfv( GLenum pname, const GLfloat *params )
07745 {
07746   NVSG_GL_STATS_LIGHT_MODELFV( pname, params );
07747   glLightModelfv( pname, params );
07748   ASSERT_GL_NO_ERROR;
07749 }
07750
07751 inline void _GLLightModeli( GLenum pname, GLint param )
07752 {
07753   NVSG_GL_STATS_LIGHT_MODELI( pname, param );
07754   glLightModeli( pname, param );
07755   ASSERT_GL_NO_ERROR;
07756 }
07757
07758 inline void _GLLightModeliv( GLenum pname, const GLint *params )
07759 {
07760   NVSG_GL_STATS_LIGHT_MODELIV( pname, params );
07761   glLightModeliv( pname, params );
07762   ASSERT_GL_NO_ERROR;
07763 }
07764
07765 inline  void  _GLMaterialf( GLenum face, GLenum pname, GLfloat param )
07766 {
07767   NVSG_GL_STATS_MATERIALF( face, pname, param );
07768   glMaterialf( face, pname, param );
07769   ASSERT_GL_NO_ERROR;
07770 }
07771
07772 inline void _GLMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
07773 {
07774   NVSG_GL_STATS_MATERIALFV( face, pname, params );
07775   glMaterialfv( face, pname, params );
07776   ASSERT_GL_NO_ERROR;
07777 }
07778
07779 inline void _GLMateriali( GLenum face, GLenum pname, GLint param )
07780 {
07781   NVSG_GL_STATS_MATERIALI( face, pname, param );
07782   glMateriali( face, pname, param );
07783   ASSERT_GL_NO_ERROR;
07784 }
07785
07786 inline void _GLMaterialiv( GLenum face, GLenum pname, const GLint *params )
07787 {
07788   NVSG_GL_STATS_MATERIALIV( face, pname, params );
07789   glMaterialiv( face, pname, params );
07790   ASSERT_GL_NO_ERROR;
07791 }
07792
07793 inline void _GLPolygonMode( GLenum face, GLenum mode )
07794 {
07795   NVSG_GL_STATS_POLYGON_MODE( face, mode );
07796   glPolygonMode( face, mode );
07797   ASSERT_GL_NO_ERROR;
07798 }
07799
07800 inline  void  _GLTexEnvf( GLenum target, GLenum pname, GLfloat param )
07801 {
07802   NVSG_GL_STATS_TEX_ENVF( target, pname, param );
07803   glTexEnvf( target, pname, param );
07804   ASSERT_GL_NO_ERROR;
07805 }
07806
07807 inline void _GLTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
07808 {
07809   NVSG_GL_STATS_TEX_ENVFV( target, pname, params );
07810   glTexEnvfv( target, pname, params );
07811   ASSERT_GL_NO_ERROR;
07812 }
07813
07814 inline void _GLTexEnvi( GLenum target, GLenum pname, GLint param )
07815 {
07816   NVSG_GL_STATS_TEX_ENVI( target, pname, param );
07817   glTexEnvi( target, pname, param );
07818   ASSERT_GL_NO_ERROR;
07819 }
07820
07821 inline void _GLTexEnviv( GLenum target, GLenum pname, const GLint *params )
07822 {
07823   NVSG_GL_STATS_TEX_ENVIV( target, pname, params );
07824   glTexEnviv( target, pname, params );
07825   ASSERT_GL_NO_ERROR;
07826 }
07827
07828 inline  void  _GLTexParameterf( GLenum target, GLenum pname, GLfloat param )
07829 {
07830   NVSG_GL_STATS_TEX_PARAMETERF( target, pname, param );
07831   glTexParameterf( target, pname, param );
07832   ASSERT_GL_NO_ERROR;
07833 }
07834
07835 inline void _GLTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
07836 {
07837   NVSG_GL_STATS_TEX_PARAMETERFV( target, pname, params );
07838   glTexParameterfv( target, pname, params );
07839   ASSERT_GL_NO_ERROR;
07840 }
07841
07842 inline void _GLTexParameteri( GLenum target, GLenum pname, GLint param )
07843 {
07844   NVSG_GL_STATS_TEX_PARAMETERI( target, pname, param );
07845   glTexParameteri( target, pname, param );
07846   ASSERT_GL_NO_ERROR;
07847 }
07848
07849 inline void _GLTexParameteriv( GLenum target, GLenum pname, const GLint *params )
07850 {
07851   NVSG_GL_STATS_TEX_PARAMETERIV( target, pname, params );
07852   glTexParameteriv( target, pname, params );
07853   ASSERT_GL_NO_ERROR;
07854 }
07855
07856 #if defined( GL_CACHING )
07857
07858 inline  void  _GLUpdateActiveTexture( void )
07859 {
07860   GLContext * ctx = glContext();
07861   if ( ctx->m_textureAttributes.m_toActivate != ctx->m_textureAttributes.m_active )
07862   {
07863 #if !defined(NDEBUG)
07864     GLint at;
07865     glGetIntegerv( GL_ACTIVE_TEXTURE, &at );
07866     NVSG_ASSERT( at == GL_TEXTURE0 + ctx->m_textureAttributes.m_active );
07867 #endif
07868     ctx->m_textureAttributes.m_active = ctx->m_textureAttributes.m_toActivate;
07869     NVSG_GL_STATS_ACTIVE_TEXTURE( GL_TEXTURE0 + ctx->m_textureAttributes.m_active );
07870     ctx->m_glFunctions->glActiveTexture( GL_TEXTURE0 + ctx->m_textureAttributes.m_active );
07871   }
07872 }
07873
07874 inline  void  _GLUpdateClientActiveTexture( void )
07875 {
07876   GLContext * ctx = glContext();
07877   if ( ctx->m_vertexArrayAttributes.m_clientTextureToActivate != ctx->m_vertexArrayAttributes.m_clientTextureActive )
07878   {
07879 #if !defined(NDEBUG)
07880     GLint cat;
07881     glGetIntegerv( GL_CLIENT_ACTIVE_TEXTURE, &cat );
07882     NVSG_ASSERT( cat == GL_TEXTURE0 + ctx->m_vertexArrayAttributes.m_clientTextureActive );
07883 #endif
07884     ctx->m_vertexArrayAttributes.m_clientTextureActive = ctx->m_vertexArrayAttributes.m_clientTextureToActivate;
07885     NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( GL_TEXTURE0 + ctx->m_vertexArrayAttributes.m_clientTextureActive );
07886     ctx->m_glFunctions->glClientActiveTexture( GL_TEXTURE0 + ctx->m_vertexArrayAttributes.m_clientTextureActive );
07887   }
07888 }
07889
07890 #endif
07891
07892 #endif
07893
07894 } // namespace nvgl
Generated on Fri Aug 4 08:33:03 2006 for NVSGSDK by NVIDIA


GLDALData.h File Reference

#include "nvsg/DAL.h"
#include "nvgl/GLContext.h"
#include "nvsg/VertexAttributeSet.h"
#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 Fri Aug 4 08:33:43 2006 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 <set>
00019
00020 namespace nvgl
00021 {
00022   // identifier for device abstraction layer data
00023   enum
00024   {
00025     GL_VBO = 0x00000001
00026     , GL_DL  = 0x00000002
00027     , GL_TEX = 0x00000004
00028   };
00029
00030   struct GLDALDataCreator : public nvsg::DALDataCreator
00031   {
00032     NVSG_API ~GLDALDataCreator();
00033     NVSG_API void onReleaseDAL(nvsg::HDAL);
00034     NVSG_API void exit();
00035     std::set<nvsg::HDAL> m_dlists;
00036     std::set<nvsg::HDAL> m_vbos;
00037     std::set<nvsg::HDAL> m_textures;
00038   };
00039
00040   struct GLDALData : public nvsg::DALData
00041   {
00042     NVSG_API GLDALData(nvsg::DALDataCreator * creator);
00043     NVSG_API virtual ~GLDALData();
00044     GLContext * context;
00045   };
00046
00047   // DAL data carrying device dependent texture IDs
00048   struct GLTextureCache : public GLDALData
00049   {
00050     NVSG_API GLTextureCache(nvsg::DALDataCreator * creator);
00051     NVSG_API GLTextureCache(nvsg::DALDataCreator * creator, GLuint tex, GLenum tgt);
00052     NVSG_API ~GLTextureCache();
00053
00054     GLuint texture; // GL name of the texture object
00055     GLenum target; // GL target
00056   };
00057
00058   struct GLDisplayListCache : public GLDALData
00059   {
00060     NVSG_API GLDisplayListCache(nvsg::DALDataCreator * creator);
00061     NVSG_API ~GLDisplayListCache();
00062
00063     GLuint listID;
00064   };
00065
00066   struct GLArrayBufferCache : public GLDALData
00067   {
00068     GLArrayBufferCache(nvsg::DALDataCreator * creator);
00069     ~GLArrayBufferCache();
00070
00071     GLuint vbo;   // vertex buffer identifier
00072     GLsizei stride;         // byte offset between consecutive vertex attribute data of same type
00073     GLsizeiptr attribOffsets[nvsg::VertexAttributeSet::NUMBER_OF_VERTEX_ATTRIBUTES]; // per vertex attribute offset into vertex buffer
00074     GLenum attribType[nvsg::VertexAttributeSet::NUMBER_OF_VERTEX_ATTRIBUTES]; // per attribute type
00075   };
00076
00077   struct GLElementArrayBufferCache : public GLDALData
00078   {
00079     GLElementArrayBufferCache(nvsg::DALDataCreator * creator);
00080     ~GLElementArrayBufferCache();
00081
00082     GLuint ibo;   // index buffer identifier
00083     GLsizeiptr indexOffset; // offest into index buffer
00084     GLenum indexType;      // type used with indices (either GL_UNSIGNED_INT or GL_UNSIGNED_SHORT)
00085     GLsizei numIndices;     // total number of indices
00086     GLuint  startIndex;   // start - end range for glDrawRangeElements
00087     GLuint  endIndex;     // ...
00088     // multi draw elements related
00089     GLvoid ** primitiveOffsets;    // per primitive offset into index buffer
00090     GLsizei * primitiveIndexCount; // per primitive index count
00091   };
00092
00093 }
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:33:44 2006 for NVSGSDK by NVIDIA


GLFunctions.h Source File

GLFunctions.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  <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
00055       bool  isExported( const std::string& extension
00056                       ) const;
00057
00058     public:
00059 //  Don't need to document all these wrapper functions !!!
00060 #if ! defined( DOXYGEN_IGNORE )
00061       //  version 1.2 functions
00062       PFNGLBLENDCOLORPROC                         glBlendColor;
00063       PFNGLBLENDEQUATIONPROC                      glBlendEquation;
00064       PFNGLCOLORTABLEPROC                         glColorTable;
00065       PFNGLCOLORTABLEPARAMETERFVPROC              glColorTableParameterfv;
00066       PFNGLCOLORTABLEPARAMETERIVPROC              glColorTableParameteriv;
00067       PFNGLCOPYCOLORTABLEPROC                     glCopyColorTable;
00068       PFNGLCOPYTEXSUBIMAGE3DPROC                  glCopyTexSubImage3D;
00069       PFNGLDRAWRANGEELEMENTSPROC                  glDrawRangeElements;
00070       PFNGLGETCOLORTABLEPROC                      glGetColorTable;
00071       PFNGLGETCOLORTABLEPARAMETERFVPROC           glGetColorTableParameterfv;
00072       PFNGLGETCOLORTABLEPARAMETERIVPROC           glGetColorTableParameteriv;
00073       PFNGLTEXIMAGE3DPROC                         glTexImage3D;
00074       PFNGLTEXSUBIMAGE3DPROC                      glTexSubImage3D;
00075
00076       //  version 1.3 functions
00077       PFNGLACTIVETEXTUREPROC                      glActiveTexture;
00078       PFNGLCLIENTACTIVETEXTUREPROC                glClientActiveTexture;
00079       PFNGLCOMPRESSEDTEXIMAGE3DPROC               glCompressedTexImage3D;
00080       PFNGLCOMPRESSEDTEXIMAGE2DPROC               glCompressedTexImage2D;
00081       PFNGLCOMPRESSEDTEXIMAGE1DPROC               glCompressedTexImage1D;
00082       PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC            glCompressedTexSubImage3D;
00083       PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC            glCompressedTexSubImage2D;
00084       PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC            glCompressedTexSubImage1D;
00085       PFNGLGETCOMPRESSEDTEXIMAGEPROC              glGetCompressedTexImage;
00086       PFNGLLOADTRANSPOSEMATRIXFPROC               glLoadTransposeMatrixf;
00087       PFNGLLOADTRANSPOSEMATRIXDPROC               glLoadTransposeMatrixd;
00088       PFNGLMULTITEXCOORD1DPROC                    glMultiTexCoord1d;
00089       PFNGLMULTITEXCOORD1DVPROC                   glMultiTexCoord1dv;
00090       PFNGLMULTITEXCOORD1FPROC                    glMultiTexCoord1f;
00091       PFNGLMULTITEXCOORD1FVPROC                   glMultiTexCoord1fv;
00092       PFNGLMULTITEXCOORD1IPROC                    glMultiTexCoord1i;
00093       PFNGLMULTITEXCOORD1IVPROC                   glMultiTexCoord1iv;
00094       PFNGLMULTITEXCOORD1SPROC                    glMultiTexCoord1s;
00095       PFNGLMULTITEXCOORD1SVPROC                   glMultiTexCoord1sv;
00096       PFNGLMULTITEXCOORD2DPROC                    glMultiTexCoord2d;
00097       PFNGLMULTITEXCOORD2DVPROC                   glMultiTexCoord2dv;
00098       PFNGLMULTITEXCOORD2FPROC                    glMultiTexCoord2f;
00099       PFNGLMULTITEXCOORD2FVPROC                   glMultiTexCoord2fv;
00100       PFNGLMULTITEXCOORD2IPROC                    glMultiTexCoord2i;
00101       PFNGLMULTITEXCOORD2IVPROC                   glMultiTexCoord2iv;
00102       PFNGLMULTITEXCOORD2SPROC                    glMultiTexCoord2s;
00103       PFNGLMULTITEXCOORD2SVPROC                   glMultiTexCoord2sv;
00104       PFNGLMULTITEXCOORD3DPROC                    glMultiTexCoord3d;
00105       PFNGLMULTITEXCOORD3DVPROC                   glMultiTexCoord3dv;
00106       PFNGLMULTITEXCOORD3FPROC                    glMultiTexCoord3f;
00107       PFNGLMULTITEXCOORD3FVPROC                   glMultiTexCoord3fv;
00108       PFNGLMULTITEXCOORD3IPROC                    glMultiTexCoord3i;
00109       PFNGLMULTITEXCOORD3IVPROC                   glMultiTexCoord3iv;
00110       PFNGLMULTITEXCOORD3SPROC                    glMultiTexCoord3s;
00111       PFNGLMULTITEXCOORD3SVPROC                   glMultiTexCoord3sv;
00112       PFNGLMULTITEXCOORD4DPROC                    glMultiTexCoord4d;
00113       PFNGLMULTITEXCOORD4DVPROC                   glMultiTexCoord4dv;
00114       PFNGLMULTITEXCOORD4FPROC                    glMultiTexCoord4f;
00115       PFNGLMULTITEXCOORD4FVPROC                   glMultiTexCoord4fv;
00116       PFNGLMULTITEXCOORD4IPROC                    glMultiTexCoord4i;
00117       PFNGLMULTITEXCOORD4IVPROC                   glMultiTexCoord4iv;
00118       PFNGLMULTITEXCOORD4SPROC                    glMultiTexCoord4s;
00119       PFNGLMULTITEXCOORD4SVPROC                   glMultiTexCoord4sv;
00120       PFNGLMULTTRANSPOSEMATRIXFPROC               glMultTransposeMatrixf;
00121       PFNGLMULTTRANSPOSEMATRIXDPROC               glMultTransposeMatrixd;
00122       PFNGLSAMPLECOVERAGEPROC                     glSampleCoverage;
00123
00124       //  version 1.4 functions
00125       PFNGLBLENDFUNCSEPARATEPROC                  glBlendFuncSeparate;
00126       PFNGLFOGCOORDDPROC                          glFogCoordd;
00127       PFNGLFOGCOORDDVPROC                         glFogCoorddv;
00128       PFNGLFOGCOORDFPROC                          glFogCoordf;
00129       PFNGLFOGCOORDFVPROC                         glFogCoordfv;
00130       PFNGLFOGCOORDPOINTERPROC                    glFogCoordPointer;
00131       PFNGLMULTIDRAWARRAYSPROC                    glMultiDrawArrays;
00132       PFNGLMULTIDRAWELEMENTSPROC                  glMultiDrawElements;
00133       PFNGLPOINTPARAMETERFPROC                    glPointParameterf;
00134       PFNGLPOINTPARAMETERFVPROC                   glPointParameterfv;
00135       PFNGLPOINTPARAMETERIPROC                    glPointParameteri;
00136       PFNGLPOINTPARAMETERIVPROC                   glPointParameteriv;
00137       PFNGLSECONDARYCOLOR3BPROC                   glSecondaryColor3b;
00138       PFNGLSECONDARYCOLOR3BVPROC                  glSecondaryColor3bv;
00139       PFNGLSECONDARYCOLOR3DPROC                   glSecondaryColor3d;
00140       PFNGLSECONDARYCOLOR3DVPROC                  glSecondaryColor3dv;
00141       PFNGLSECONDARYCOLOR3FPROC                   glSecondaryColor3f;
00142       PFNGLSECONDARYCOLOR3FVPROC                  glSecondaryColor3fv;
00143       PFNGLSECONDARYCOLOR3IPROC                   glSecondaryColor3i;
00144       PFNGLSECONDARYCOLOR3IVPROC                  glSecondaryColor3iv;
00145       PFNGLSECONDARYCOLOR3SPROC                   glSecondaryColor3s;
00146       PFNGLSECONDARYCOLOR3SVPROC                  glSecondaryColor3sv;
00147       PFNGLSECONDARYCOLOR3UBPROC                  glSecondaryColor3ub;
00148       PFNGLSECONDARYCOLOR3UBVPROC                 glSecondaryColor3ubv;
00149       PFNGLSECONDARYCOLOR3UIPROC                  glSecondaryColor3ui;
00150       PFNGLSECONDARYCOLOR3UIVPROC                 glSecondaryColor3uiv;
00151       PFNGLSECONDARYCOLOR3USPROC                  glSecondaryColor3us;
00152       PFNGLSECONDARYCOLOR3USVPROC                 glSecondaryColor3usv;
00153       PFNGLSECONDARYCOLORPOINTERPROC              glSecondaryColorPointer;
00154       PFNGLWINDOWPOS2DPROC                        glWindowPos2d;
00155       PFNGLWINDOWPOS2FPROC                        glWindowPos2f;
00156       PFNGLWINDOWPOS2IPROC                        glWindowPos2i;
00157       PFNGLWINDOWPOS2SPROC                        glWindowPos2s;
00158       PFNGLWINDOWPOS2DVPROC                       glWindowPos2dv;
00159       PFNGLWINDOWPOS2FVPROC                       glWindowPos2fv;
00160       PFNGLWINDOWPOS2IVPROC                       glWindowPos2iv;
00161       PFNGLWINDOWPOS2SVPROC                       glWindowPos2sv;
00162       PFNGLWINDOWPOS3DPROC                        glWindowPos3d;
00163       PFNGLWINDOWPOS3FPROC                        glWindowPos3f;
00164       PFNGLWINDOWPOS3IPROC                        glWindowPos3i;
00165       PFNGLWINDOWPOS3SPROC                        glWindowPos3s;
00166       PFNGLWINDOWPOS3DVPROC                       glWindowPos3dv;
00167       PFNGLWINDOWPOS3FVPROC                       glWindowPos3fv;
00168       PFNGLWINDOWPOS3IVPROC                       glWindowPos3iv;
00169       PFNGLWINDOWPOS3SVPROC                       glWindowPos3sv;
00170
00171       //  GL_ARB_fragment_program functions see GL_ARB_vertex_program
00172
00173       //  GL_ARB_imaging functions
00174       PFNGLCOLORSUBTABLEPROC                      glColorSubTable;
00175       PFNGLCOPYCOLORSUBTABLEPROC                  glCopyColorSubTable;
00176       PFNGLCONVOLUTIONFILTER1DPROC                glConvolutionFilter1D;
00177       PFNGLCONVOLUTIONFILTER2DPROC                glConvolutionFilter2D;
00178       PFNGLCONVOLUTIONPARAMETERFPROC              glConvolutionParameterf;
00179       PFNGLCONVOLUTIONPARAMETERFVPROC             glConvolutionParameterfv;
00180       PFNGLCONVOLUTIONPARAMETERIPROC              glConvolutionParameteri;
00181       PFNGLCONVOLUTIONPARAMETERIVPROC             glConvolutionParameteriv;
00182       PFNGLCOPYCONVOLUTIONFILTER1DPROC            glCopyConvolutionFilter1D;
00183       PFNGLCOPYCONVOLUTIONFILTER2DPROC            glCopyConvolutionFilter2D;
00184       PFNGLGETCONVOLUTIONFILTERPROC               glGetConvolutionFilter;
00185       PFNGLGETCONVOLUTIONPARAMETERFVPROC          glGetConvolutionParameterfv;
00186       PFNGLGETCONVOLUTIONPARAMETERIVPROC          glGetConvolutionParameteriv;
00187       PFNGLGETSEPARABLEFILTERPROC                 glGetSeparableFilter;
00188       PFNGLSEPARABLEFILTER2DPROC                  glSeparableFilter2D;
00189       PFNGLGETHISTOGRAMPROC                       glGetHistogram;
00190       PFNGLGETHISTOGRAMPARAMETERFVPROC            glGetHistogramParameterfv;
00191       PFNGLGETHISTOGRAMPARAMETERIVPROC            glGetHistogramParameteriv;
00192       PFNGLGETMINMAXPROC                          glGetMinmax;
00193       PFNGLGETMINMAXPARAMETERFVPROC               glGetMinmaxParameterfv;
00194       PFNGLGETMINMAXPARAMETERIVPROC               glGetMinmaxParameteriv;
00195       PFNGLHISTOGRAMPROC                          glHistogram;
00196       PFNGLMINMAXPROC                             glMinmax;
00197       PFNGLRESETHISTOGRAMPROC                     glResetHistogram;
00198       PFNGLRESETMINMAXPROC                        glResetMinmax;
00199
00200       //  GL_ARB_occlusion_query
00201       PFNGLGENQUERIESARBPROC                      glGenQueriesARB;
00202       PFNGLDELETEQUERIESARBPROC                   glDeleteQueriesARB;
00203       PFNGLISQUERYARBPROC                         glIsQueryARB;
00204       PFNGLBEGINQUERYARBPROC                      glBeginQueryARB;
00205       PFNGLENDQUERYARBPROC                        glEndQueryARB;
00206       PFNGLGETQUERYOBJECTIVARBPROC                glGetQueryObjectivARB;
00207       PFNGLGETQUERYOBJECTUIVARBPROC               glGetQueryObjectuivARB;
00208       PFNGLGETQUERYIVARBPROC                      glGetQueryivARB;
00209
00210       //  GL_ARB_point_parameters
00211       PFNGLPOINTPARAMETERFARBPROC                 glPointParameterfARB;
00212       PFNGLPOINTPARAMETERFVARBPROC                glPointParameterfvARB;
00213
00214       //  GL_ARB_vertex_buffer_object functions
00215       PFNGLBINDBUFFERARBPROC                      glBindBufferARB;
00216       PFNGLBUFFERDATAARBPROC                      glBufferDataARB;
00217       PFNGLBUFFERSUBDATAARBPROC                   glBufferSubDataARB;
00218       PFNGLDELETEBUFFERSARBPROC                   glDeleteBuffersARB;
00219       PFNGLGENBUFFERSARBPROC                      glGenBuffersARB;
00220       PFNGLGETBUFFERPARAMETERIVARBPROC            glGetBufferParameterivARB;
00221       PFNGLGETBUFFERPOINTERVARBPROC               glGetBufferPointervARB;
00222       PFNGLGETBUFFERSUBDATAARBPROC                glGetBufferSubDataARB;
00223       PFNGLISBUFFERARBPROC                        glIsBufferARB;
00224       PFNGLMAPBUFFERARBPROC                       glMapBufferARB;
00225       PFNGLUNMAPBUFFERARBPROC                     glUnmapBufferARB;
00226
00227       //  GL_ARB_vertex_program functions
00228       PFNGLBINDPROGRAMARBPROC                     glBindProgramARB;
00229       PFNGLENABLEVERTEXATTRIBARRAYARBPROC         glEnableVertexAttribArrayARB;
00230       PFNGLDELETEPROGRAMSARBPROC                  glDeleteProgramsARB;
00231       PFNGLDISABLEVERTEXATTRIBARRAYARBPROC        glDisableVertexAttribArrayARB;
00232       PFNGLGENPROGRAMSARBPROC                     glGenProgramsARB;
00233       PFNGLGETPROGRAMENVPARAMETERDVARBPROC        glGetProgramEnvParameterdvARB;
00234       PFNGLGETPROGRAMENVPARAMETERFVARBPROC        glGetProgramEnvParameterfvARB;
00235       PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC      glGetProgramLocalParameterdvARB;
00236       PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC      glGetProgramLocalParameterfvARB;
00237       PFNGLGETPROGRAMSTRINGARBPROC                glGetProgramStringARB;
00238       PFNGLGETPROGRAMIVARBPROC                    glGetProgramivARB;
00239       PFNGLGETVERTEXATTRIBDVARBPROC               glGetVertexAttribdvARB;
00240       PFNGLGETVERTEXATTRIBFVARBPROC               glGetVertexAttribfvARB;
00241       PFNGLGETVERTEXATTRIBIVARBPROC               glGetVertexAttribivARB;
00242       PFNGLGETVERTEXATTRIBPOINTERVARBPROC         glGetVertexAttribPointervARB;
00243       PFNGLISPROGRAMARBPROC                       glIsProgramARB;
00244       PFNGLPROGRAMENVPARAMETER4DARBPROC           glProgramEnvParameter4dARB;
00245       PFNGLPROGRAMENVPARAMETER4DVARBPROC          glProgramEnvParameter4dvARB;
00246       PFNGLPROGRAMENVPARAMETER4FARBPROC           glProgramEnvParameter4fARB;
00247       PFNGLPROGRAMENVPARAMETER4FVARBPROC          glProgramEnvParameter4fvARB;
00248       PFNGLPROGRAMLOCALPARAMETER4DARBPROC         glProgramLocalParameter4dARB;
00249       PFNGLPROGRAMLOCALPARAMETER4DVARBPROC        glProgramLocalParameter4dvARB;
00250       PFNGLPROGRAMLOCALPARAMETER4FARBPROC         glProgramLocalParameter4fARB;
00251       PFNGLPROGRAMLOCALPARAMETER4FVARBPROC        glProgramLocalParameter4fvARB;
00252       PFNGLPROGRAMSTRINGARBPROC                   glProgramStringARB;
00253       PFNGLVERTEXATTRIB1DARBPROC                  glVertexAttrib1dARB;
00254       PFNGLVERTEXATTRIB1DVARBPROC                 glVertexAttrib1dvARB;
00255       PFNGLVERTEXATTRIB1FARBPROC                  glVertexAttrib1fARB;
00256       PFNGLVERTEXATTRIB1FVARBPROC                 glVertexAttrib1fvARB;
00257       PFNGLVERTEXATTRIB1SARBPROC                  glVertexAttrib1sARB;
00258       PFNGLVERTEXATTRIB1SVARBPROC                 glVertexAttrib1svARB;
00259       PFNGLVERTEXATTRIB2DARBPROC                  glVertexAttrib2dARB;
00260       PFNGLVERTEXATTRIB2DVARBPROC                 glVertexAttrib2dvARB;
00261       PFNGLVERTEXATTRIB2FARBPROC                  glVertexAttrib2fARB;
00262       PFNGLVERTEXATTRIB2FVARBPROC                 glVertexAttrib2fvARB;
00263       PFNGLVERTEXATTRIB2SARBPROC                  glVertexAttrib2sARB;
00264       PFNGLVERTEXATTRIB2SVARBPROC                 glVertexAttrib2svARB;
00265       PFNGLVERTEXATTRIB3DARBPROC                  glVertexAttrib3dARB;
00266       PFNGLVERTEXATTRIB3DVARBPROC                 glVertexAttrib3dvARB;
00267       PFNGLVERTEXATTRIB3FARBPROC                  glVertexAttrib3fARB;
00268       PFNGLVERTEXATTRIB3FVARBPROC                 glVertexAttrib3fvARB;
00269       PFNGLVERTEXATTRIB3SARBPROC                  glVertexAttrib3sARB;
00270       PFNGLVERTEXATTRIB3SVARBPROC                 glVertexAttrib3svARB;
00271       PFNGLVERTEXATTRIB4NBVARBPROC                glVertexAttrib4NbvARB;
00272       PFNGLVERTEXATTRIB4NIVARBPROC                glVertexAttrib4NivARB;
00273       PFNGLVERTEXATTRIB4NSVARBPROC                glVertexAttrib4NsvARB;
00274       PFNGLVERTEXATTRIB4NUBARBPROC                glVertexAttrib4NubARB;
00275       PFNGLVERTEXATTRIB4NUBVARBPROC               glVertexAttrib4NubvARB;
00276       PFNGLVERTEXATTRIB4NUIVARBPROC               glVertexAttrib4NuivARB;
00277       PFNGLVERTEXATTRIB4NUSVARBPROC               glVertexAttrib4NusvARB;
00278       PFNGLVERTEXATTRIB4BVARBPROC                 glVertexAttrib4bvARB;
00279       PFNGLVERTEXATTRIB4DARBPROC                  glVertexAttrib4dARB;
00280       PFNGLVERTEXATTRIB4DVARBPROC                 glVertexAttrib4dvARB;
00281       PFNGLVERTEXATTRIB4FARBPROC                  glVertexAttrib4fARB;
00282       PFNGLVERTEXATTRIB4FVARBPROC                 glVertexAttrib4fvARB;
00283       PFNGLVERTEXATTRIB4IVARBPROC                 glVertexAttrib4ivARB;
00284       PFNGLVERTEXATTRIB4SARBPROC                  glVertexAttrib4sARB;
00285       PFNGLVERTEXATTRIB4SVARBPROC                 glVertexAttrib4svARB;
00286       PFNGLVERTEXATTRIB4UBVARBPROC                glVertexAttrib4ubvARB;
00287       PFNGLVERTEXATTRIB4UIVARBPROC                glVertexAttrib4uivARB;
00288       PFNGLVERTEXATTRIB4USVARBPROC                glVertexAttrib4usvARB;
00289       PFNGLVERTEXATTRIBPOINTERARBPROC             glVertexAttribPointerARB;
00290
00291       //  GL_ARB_window_pos functions
00292       PFNGLWINDOWPOS2DARBPROC                     glWindowPos2dARB;
00293       PFNGLWINDOWPOS2FARBPROC                     glWindowPos2fARB;
00294       PFNGLWINDOWPOS2IARBPROC                     glWindowPos2iARB;
00295       PFNGLWINDOWPOS2SARBPROC                     glWindowPos2sARB;
00296       PFNGLWINDOWPOS2DVARBPROC                    glWindowPos2dvARB;
00297       PFNGLWINDOWPOS2FVARBPROC                    glWindowPos2fvARB;
00298       PFNGLWINDOWPOS2IVARBPROC                    glWindowPos2ivARB;
00299       PFNGLWINDOWPOS2SVARBPROC                    glWindowPos2svARB;
00300       PFNGLWINDOWPOS3DARBPROC                     glWindowPos3dARB;
00301       PFNGLWINDOWPOS3FARBPROC                     glWindowPos3fARB;
00302       PFNGLWINDOWPOS3IARBPROC                     glWindowPos3iARB;
00303       PFNGLWINDOWPOS3SARBPROC                     glWindowPos3sARB;
00304       PFNGLWINDOWPOS3DVARBPROC                    glWindowPos3dvARB;
00305       PFNGLWINDOWPOS3FVARBPROC                    glWindowPos3fvARB;
00306       PFNGLWINDOWPOS3IVARBPROC                    glWindowPos3ivARB;
00307       PFNGLWINDOWPOS3SVARBPROC                    glWindowPos3svARB;
00308
00309       //  GL_Autodesk_valid_back_buffer_hint functions
00310       PFNGLWINDOWBACKBUFFERHINTAUTODESKPROC       glWindowBackBufferHintAutodesk;
00311       PFNGLVALIDBACKBUFFERHINTAUTODESKPROC        glValidBackBufferHintAutodesk;
00312
00313       //  GL_EXT_blend_func_separate functions
00314       PFNGLBLENDFUNCSEPARATEEXTPROC               glBlendFuncSeparateEXT;
00315
00316       //  GL_EXT_compiled_vertex_array functions
00317       PFNGLLOCKARRAYSEXTPROC                      glLockArraysEXT;
00318       PFNGLUNLOCKARRAYSEXTPROC                    glUnlockArraysEXT;
00319
00320       //  GL_EXT_depth_bounds_test functions
00321       PFNGLDEPTHBOUNDSEXTPROC                     glDepthBoundsEXT;
00322
00323       //  GL_EXT_point_parameters functions
00324       PFNGLPOINTPARAMETERFEXTPROC                 glPointParameterfEXT;
00325       PFNGLPOINTPARAMETERFVEXTPROC                glPointParameterfvEXT;
00326
00327       //  GL_EXT_stencil_two_side functions
00328       PFNGLACTIVESTENCILFACEEXTPROC               glActiveStencilFaceEXT;
00329
00330       //  GL_NV_fence functions
00331       PFNGLDELETEFENCESNVPROC                     glDeleteFencesNV;
00332       PFNGLFINISHFENCENVPROC                      glFinishFenceNV;
00333       PFNGLGENFENCESNVPROC                        glGenFencesNV;
00334       PFNGLGETFENCEIVNVPROC                       glGetFenceivNV;
00335       PFNGLISFENCENVPROC                          glIsFenceNV;
00336       PFNGLSETFENCENVPROC                         glSetFenceNV;
00337       PFNGLTESTFENCENVPROC                        glTestFenceNV;
00338
00339       //  GL_NV_fragment_program functions
00340       PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC       glGetProgramNamedParameterdvNV;
00341       PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC       glGetProgramNamedParameterfvNV;
00342       PFNGLPROGRAMNAMEDPARAMETER4DNVPROC          glProgramNamedParameter4dNV;
00343       PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC         glProgramNamedParameter4dvNV;
00344       PFNGLPROGRAMNAMEDPARAMETER4FNVPROC          glProgramNamedParameter4fNV;
00345       PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC         glProgramNamedParameter4fvNV;
00346
00347       //  GL_NV_half_float functions
00348       PFNGLCOLOR3HNVPROC                          glColor3hNV;
00349       PFNGLCOLOR3HVNVPROC                         glColor3hvNV;
00350       PFNGLCOLOR4HNVPROC                          glColor4hNV;
00351       PFNGLCOLOR4HVNVPROC                         glColor4hvNV;
00352       PFNGLFOGCOORDHNVPROC                        glFogCoordhNV;
00353       PFNGLFOGCOORDHVNVPROC                       glFogCoordhvNV;
00354       PFNGLMULTITEXCOORD1HNVPROC                  glMultiTexCoord1hNV;
00355       PFNGLMULTITEXCOORD1HVNVPROC                 glMultiTexCoord1hvNV;
00356       PFNGLMULTITEXCOORD2HNVPROC                  glMultiTexCoord2hNV;
00357       PFNGLMULTITEXCOORD2HVNVPROC                 glMultiTexCoord2hvNV;
00358       PFNGLMULTITEXCOORD3HNVPROC                  glMultiTexCoord3hNV;
00359       PFNGLMULTITEXCOORD3HVNVPROC                 glMultiTexCoord3hvNV;
00360       PFNGLMULTITEXCOORD4HNVPROC                  glMultiTexCoord4hNV;
00361       PFNGLMULTITEXCOORD4HVNVPROC                 glMultiTexCoord4hvNV;
00362       PFNGLNORMAL3HNVPROC                         glNormal3hNV;
00363       PFNGLNORMAL3HVNVPROC                        glNormal3hvNV;
00364       PFNGLSECONDARYCOLOR3HNVPROC                 glSecondaryColor3hNV;
00365       PFNGLSECONDARYCOLOR3HVNVPROC                glSecondaryColor3hvNV;
00366       PFNGLTEXCOORD1HNVPROC                       glTexCoord1hNV;
00367       PFNGLTEXCOORD1HVNVPROC                      glTexCoord1hvNV;
00368       PFNGLTEXCOORD2HNVPROC                       glTexCoord2hNV;
00369       PFNGLTEXCOORD2HVNVPROC                      glTexCoord2hvNV;
00370       PFNGLTEXCOORD3HNVPROC                       glTexCoord3hNV;
00371       PFNGLTEXCOORD3HVNVPROC                      glTexCoord3hvNV;
00372       PFNGLTEXCOORD4HNVPROC                       glTexCoord4hNV;
00373       PFNGLTEXCOORD4HVNVPROC                      glTexCoord4hvNV;
00374       PFNGLVERTEX2HNVPROC                         glVertex2hNV;
00375       PFNGLVERTEX2HVNVPROC                        glVertex2hvNV;
00376       PFNGLVERTEX3HNVPROC                         glVertex3hNV;
00377       PFNGLVERTEX3HVNVPROC                        glVertex3hvNV;
00378       PFNGLVERTEX4HNVPROC                         glVertex4hNV;
00379       PFNGLVERTEX4HVNVPROC                        glVertex4hvNV;
00380       PFNGLVERTEXATTRIB1HNVPROC                   glVertexAttrib1hNV;
00381       PFNGLVERTEXATTRIB1HVNVPROC                  glVertexAttrib1hvNV;
00382       PFNGLVERTEXATTRIB2HNVPROC                   glVertexAttrib2hNV;
00383       PFNGLVERTEXATTRIB2HVNVPROC                  glVertexAttrib2hvNV;
00384       PFNGLVERTEXATTRIB3HNVPROC                   glVertexAttrib3hNV;
00385       PFNGLVERTEXATTRIB3HVNVPROC                  glVertexAttrib3hvNV;
00386       PFNGLVERTEXATTRIB4HNVPROC                   glVertexAttrib4hNV;
00387       PFNGLVERTEXATTRIB4HVNVPROC                  glVertexAttrib4hvNV;
00388       PFNGLVERTEXATTRIBS1HVNVPROC                 glVertexAttribs1hvNV;
00389       PFNGLVERTEXATTRIBS2HVNVPROC                 glVertexAttribs2hvNV;
00390       PFNGLVERTEXATTRIBS3HVNVPROC                 glVertexAttribs3hvNV;
00391       PFNGLVERTEXATTRIBS4HVNVPROC                 glVertexAttribs4hvNV;
00392
00393       //  GL_NV_occlusion_query functions
00394       PFNGLBEGINOCCLUSIONQUERYNVPROC              glBeginOcclusionQueryNV;
00395       PFNGLDELETEOCCLUSIONQUERIESNVPROC           glDeleteOcclusionQueriesNV;
00396       PFNGLENDOCCLUSIONQUERYNVPROC                glEndOcclusionQueryNV;
00397       PFNGLGENOCCLUSIONQUERIESNVPROC              glGenOcclusionQueriesNV;
00398       PFNGLGETOCCLUSIONQUERYIVNVPROC              glGetOcclusionQueryivNV;
00399       PFNGLGETOCCLUSIONQUERYUIVNVPROC             glGetOcclusionQueryuivNV;
00400       PFNGLISOCCLUSIONQUERYNVPROC                 glIsOcclusionQueryNV;
00401
00402       //  GL_NV_pixel_data_range functions
00403       PFNGLFLUSHPIXELDATARANGENVPROC              glFlushPixelDataRangeNV;
00404       PFNGLPIXELDATARANGENVPROC                   glPixelDataRangeNV;
00405
00406       //  GL_NV_primitive_restart functions
00407       PFNGLPRIMITIVERESTARTNVPROC                 glPrimitiveRestartNV;
00408       PFNGLPRIMITIVERESTARTINDEXNVPROC            glPrimitiveRestartIndexNV;
00409
00410       //  GL_NV_register_combiners functions
00411       PFNGLCOMBINERPARAMETERFVNVPROC              glCombinerParameterfvNV;
00412       PFNGLCOMBINERPARAMETERFNVPROC               glCombinerParameterfNV;
00413       PFNGLCOMBINERPARAMETERIVNVPROC              glCombinerParameterivNV;
00414       PFNGLCOMBINERPARAMETERINVPROC               glCombinerParameteriNV;
00415       PFNGLCOMBINERINPUTNVPROC                    glCombinerInputNV;
00416       PFNGLCOMBINEROUTPUTNVPROC                   glCombinerOutputNV;
00417       PFNGLFINALCOMBINERINPUTNVPROC               glFinalCombinerInputNV;
00418       PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC      glGetCombinerInputParameterfvNV;
00419       PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC      glGetCombinerInputParameterivNV;
00420       PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC     glGetCombinerOutputParameterfvNV;
00421       PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC     glGetCombinerOutputParameterivNV;
00422       PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV;
00423       PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV;
00424
00425       //  GL_NV_register_combiners2 functions
00426       PFNGLCOMBINERSTAGEPARAMETERFVNVPROC         glCombinerStageParameterfvNV;
00427       PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC      glGetCombinerStageParameterfvNV;
00428
00429       //  GL_NV_set_window_stereomode functions
00430       PFNGLSETWINDOWSTEREOMODENVPROC              glSetWindowStereoModeNV;
00431
00432       //  GL_NV_vertex_array_range functions
00433       PFNGLFLUSHVERTEXARRAYRANGENVPROC            glFlushVertexArrayRangeNV;
00434       PFNGLVERTEXARRAYRANGENVPROC                 glVertexArrayRangeNV;
00435
00436       //  GL_NV_vertex_program functions
00437       PFNGLAREPROGRAMSRESIDENTNVPROC              glAreProgramsResidentNV;
00438       PFNGLBINDPROGRAMNVPROC                      glBindProgramNV;
00439       PFNGLDELETEPROGRAMSNVPROC                   glDeleteProgramsNV;
00440       PFNGLEXECUTEPROGRAMNVPROC                   glExecuteProgramNV;
00441       PFNGLGENPROGRAMSNVPROC                      glGenProgramsNV;
00442       PFNGLGETPROGRAMPARAMETERDVNVPROC            glGetProgramParameterdvNV;
00443       PFNGLGETPROGRAMPARAMETERFVNVPROC            glGetProgramParameterfvNV;
00444       PFNGLGETPROGRAMIVNVPROC                     glGetProgramivNV;
00445       PFNGLGETPROGRAMSTRINGNVPROC                 glGetProgramStringNV;
00446       PFNGLGETTRACKMATRIXIVNVPROC                 glGetTrackMatrixivNV;
00447       PFNGLGETVERTEXATTRIBDVNVPROC                glGetVertexAttribdvNV;
00448       PFNGLGETVERTEXATTRIBFVNVPROC                glGetVertexAttribfvNV;
00449       PFNGLGETVERTEXATTRIBIVNVPROC                glGetVertexAttribivNV;
00450       PFNGLGETVERTEXATTRIBPOINTERVNVPROC          glGetVertexAttribPointervNV;
00451       PFNGLISPROGRAMNVPROC                        glIsProgramNV;
00452       PFNGLLOADPROGRAMNVPROC                      glLoadProgramNV;
00453       PFNGLPROGRAMPARAMETER4DNVPROC               glProgramParameter4dNV;
00454       PFNGLPROGRAMPARAMETER4DVNVPROC              glProgramParameter4dvNV;
00455       PFNGLPROGRAMPARAMETER4FNVPROC               glProgramParameter4fNV;
00456       PFNGLPROGRAMPARAMETER4FVNVPROC              glProgramParameter4fvNV;
00457       PFNGLPROGRAMPARAMETERS4DVNVPROC             glProgramParameters4dvNV;
00458       PFNGLPROGRAMPARAMETERS4FVNVPROC             glProgramParameters4fvNV;
00459       PFNGLREQUESTRESIDENTPROGRAMSNVPROC          glRequestResidentProgramsNV;
00460       PFNGLTRACKMATRIXNVPROC                      glTrackMatrixNV;
00461       PFNGLVERTEXATTRIBPOINTERNVPROC              glVertexAttribPointerNV;
00462       PFNGLVERTEXATTRIB1DNVPROC                   glVertexAttrib1dNV;
00463       PFNGLVERTEXATTRIB1DVNVPROC                  glVertexAttrib1dvNV;
00464       PFNGLVERTEXATTRIB1FNVPROC                   glVertexAttrib1fNV;
00465       PFNGLVERTEXATTRIB1FVNVPROC                  glVertexAttrib1fvNV;
00466       PFNGLVERTEXATTRIB1SNVPROC                   glVertexAttrib1sNV;
00467       PFNGLVERTEXATTRIB1SVNVPROC                  glVertexAttrib1svNV;
00468       PFNGLVERTEXATTRIB2DNVPROC                   glVertexAttrib2dNV;
00469       PFNGLVERTEXATTRIB2DVNVPROC                  glVertexAttrib2dvNV;
00470       PFNGLVERTEXATTRIB2FNVPROC                   glVertexAttrib2fNV;
00471       PFNGLVERTEXATTRIB2FVNVPROC                  glVertexAttrib2fvNV;
00472       PFNGLVERTEXATTRIB2SNVPROC                   glVertexAttrib2sNV;
00473       PFNGLVERTEXATTRIB2SVNVPROC                  glVertexAttrib2svNV;
00474       PFNGLVERTEXATTRIB3DNVPROC                   glVertexAttrib3dNV;
00475       PFNGLVERTEXATTRIB3DVNVPROC                  glVertexAttrib3dvNV;
00476       PFNGLVERTEXATTRIB3FNVPROC                   glVertexAttrib3fNV;
00477       PFNGLVERTEXATTRIB3FVNVPROC                  glVertexAttrib3fvNV;
00478       PFNGLVERTEXATTRIB3SNVPROC                   glVertexAttrib3sNV;
00479       PFNGLVERTEXATTRIB3SVNVPROC                  glVertexAttrib3svNV;
00480       PFNGLVERTEXATTRIB4DNVPROC                   glVertexAttrib4dNV;
00481       PFNGLVERTEXATTRIB4DVNVPROC                  glVertexAttrib4dvNV;
00482       PFNGLVERTEXATTRIB4FNVPROC                   glVertexAttrib4fNV;
00483       PFNGLVERTEXATTRIB4FVNVPROC                  glVertexAttrib4fvNV;
00484       PFNGLVERTEXATTRIB4SNVPROC                   glVertexAttrib4sNV;
00485       PFNGLVERTEXATTRIB4SVNVPROC                  glVertexAttrib4svNV;
00486       PFNGLVERTEXATTRIB4UBNVPROC                  glVertexAttrib4ubNV;
00487       PFNGLVERTEXATTRIB4UBVNVPROC                 glVertexAttrib4ubvNV;
00488       PFNGLVERTEXATTRIBS1DVNVPROC                 glVertexAttribs1dvNV;
00489       PFNGLVERTEXATTRIBS1FVNVPROC                 glVertexAttribs1fvNV;
00490       PFNGLVERTEXATTRIBS1SVNVPROC                 glVertexAttribs1svNV;
00491       PFNGLVERTEXATTRIBS2DVNVPROC                 glVertexAttribs2dvNV;
00492       PFNGLVERTEXATTRIBS2FVNVPROC                 glVertexAttribs2fvNV;
00493       PFNGLVERTEXATTRIBS2SVNVPROC                 glVertexAttribs2svNV;
00494       PFNGLVERTEXATTRIBS3DVNVPROC                 glVertexAttribs3dvNV;
00495       PFNGLVERTEXATTRIBS3FVNVPROC                 glVertexAttribs3fvNV;
00496       PFNGLVERTEXATTRIBS3SVNVPROC                 glVertexAttribs3svNV;
00497       PFNGLVERTEXATTRIBS4DVNVPROC                 glVertexAttribs4dvNV;
00498       PFNGLVERTEXATTRIBS4FVNVPROC                 glVertexAttribs4fvNV;
00499       PFNGLVERTEXATTRIBS4SVNVPROC                 glVertexAttribs4svNV;
00500       PFNGLVERTEXATTRIBS4UBVNVPROC                glVertexAttribs4ubvNV;
00501
00502       //  GL_WIN_swap_hint functions
00503       PFNGLADDSWAPHINTRECTWINPROC                 glAddSwapHintRectWIN;
00504
00505       // GL_EXT_framebuffer_object
00506       PFNGLISRENDERBUFFEREXTPROC                  glIsRenderbufferEXT;
00507       PFNGLBINDRENDERBUFFEREXTPROC                glBindRenderbufferEXT;
00508       PFNGLDELETERENDERBUFFERSEXTPROC             glDeleteRenderbuffersEXT;
00509       PFNGLGENRENDERBUFFERSEXTPROC                glGenRenderbuffersEXT;
00510       PFNGLRENDERBUFFERSTORAGEEXTPROC             glRenderbufferStorageEXT;
00511       PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC      glGetRenderbufferParameterivEXT;
00512       PFNGLISFRAMEBUFFEREXTPROC                   glIsFramebufferEXT;
00513       PFNGLBINDFRAMEBUFFEREXTPROC                 glBindFramebufferEXT;
00514       PFNGLDELETEFRAMEBUFFERSEXTPROC              glDeleteFramebuffersEXT;
00515       PFNGLGENFRAMEBUFFERSEXTPROC                 glGenFramebuffersEXT;
00516       PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC          glCheckFramebufferStatusEXT;
00517       PFNGLFRAMEBUFFERTEXTURE1DEXTPROC            glFramebufferTexture1DEXT;
00518       PFNGLFRAMEBUFFERTEXTURE2DEXTPROC            glFramebufferTexture2DEXT;
00519       PFNGLFRAMEBUFFERTEXTURE3DEXTPROC            glFramebufferTexture3DEXT;
00520       PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC         glFramebufferRenderbufferEXT;
00521       PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC  glGetFramebufferAttachmentParameterivEXT;
00522       PFNGLGENERATEMIPMAPEXTPROC                       glGenerateMipmapEXT;
00523
00524 #if defined(_WIN32)
00525       //  WGL_ARB_buffer_region functions
00526       PFNWGLCREATEBUFFERREGIONARBPROC             wglCreateBufferRegionARB;
00527       PFNWGLDELETEBUFFERREGIONARBPROC             wglDeleteBufferRegionARB;
00528       PFNWGLRESTOREBUFFERREGIONARBPROC            wglRestoreBufferRegionARB;
00529       PFNWGLSAVEBUFFERREGIONARBPROC               wglSaveBufferRegionARB;
00530
00531       //  WGL_ARB_extensions_string functions
00532       PFNWGLGETEXTENSIONSSTRINGARBPROC            wglGetExtensionsStringARB;
00533
00534       //  WGL_ARB_make_current_read functions
00535       PFNWGLMAKECONTEXTCURRENTARBPROC             wglMakeContextCurrentARB;
00536       PFNWGLGETCURRENTREADDCARBPROC               wglGetCurrentReadDCARB;
00537
00538       //  WGL_ARB_pbuffer functions
00539       PFNWGLCREATEPBUFFERARBPROC                  wglCreatePbufferARB;
00540       PFNWGLDESTROYPBUFFERARBPROC                 wglDestroyPbufferARB;
00541       PFNWGLGETPBUFFERDCARBPROC                   wglGetPbufferDCARB;
00542       PFNWGLQUERYPBUFFERARBPROC                   wglQueryPbufferARB;
00543       PFNWGLRELEASEPBUFFERDCARBPROC               wglReleasePbufferDCARB;
00544
00545       //  WGL_ARB_pixel_format functions
00546       PFNWGLCHOOSEPIXELFORMATARBPROC              wglChoosePixelFormatARB;
00547       PFNWGLGETPIXELFORMATATTRIBIVARBPROC         wglGetPixelFormatAttribivARB;
00548       PFNWGLGETPIXELFORMATATTRIBFVARBPROC         wglGetPixelFormatAttribfvARB;
00549
00550       //  WGL_ARB_render_texture functions
00551       PFNWGLBINDTEXIMAGEARBPROC                   wglBindTexImageARB;
00552       PFNWGLRELEASETEXIMAGEARBPROC                wglReleaseTexImageARB;
00553       PFNWGLSETPBUFFERATTRIBARBPROC               wglSetPbufferAttribARB;
00554
00555       //  WGL_EXT_extensions_string functions
00556       PFNWGLGETEXTENSIONSSTRINGEXTPROC            wglGetExtensionsStringEXT;
00557
00558       //  WGL_EXT_genlock functions
00559       PFNWGLENABLEGENLOCKEXTPROC                  wglEnableGenlockEXT;
00560       PFNWGLDISABLEGENLOCKEXTPROC                 wglDisableGenlockEXT;
00561       PFNWGLGENLOCKSOURCEEXTPROC                  wglGenlockSourceEXT;
00562       PFNWGLGENLOCKSAMPLERATEEXTPROC              wglGenlockSampleRateEXT;
00563       PFNWGLGENLOCKSOURCEDELAYEXTPROC             wglGenlockSourceDelayEXT;
00564       PFNWGLGENLOCKSOURCEEDGEEXTPROC              wglGenlockSourceEdgeEXT;
00565       PFNWGLGETGENLOCKSOURCEEXTPROC               wglGetGenlockSourceEXT;
00566       PFNWGLGETGENLOCKSAMPLERATEEXTPROC           wglGetGenlockSampleRateEXT;
00567       PFNWGLGETGENLOCKSOURCEDELAYEXTPROC          wglGetGenlockSourceDelayEXT;
00568       PFNWGLGETGENLOCKSOURCEEDGEEXTPROC           wglGetGenlockSourceEdgeEXT;
00569       PFNWGLISENABLEDGENLOCKEXTPROC               wglIsEnabledGenlockEXT;
00570       PFNWGLQUERYGENLOCKMAXSOURCEDELAYEXTPROC     wglQueryGenlockMaxSourceDelayEXT;
00571
00572       //  WGL_EXT_swap_control functions
00573       PFNWGLSWAPINTERVALEXTPROC                   wglSwapIntervalEXT;
00574       PFNWGLGETSWAPINTERVALEXTPROC                wglGetSwapIntervalEXT;
00575
00576       //  WGL_EXT_swap_frame_lock functions
00577       PFNWGLENABLEFRAMELOCKEXTPROC                wglEnableFrameLockEXT;
00578       PFNWGLDISABLEFRAMELOCKEXTPROC               wglDisableFrameLockEXT;
00579       PFNWGLISENABLEDFRAMELOCKEXTPROC             wglIsEnabledFrameLockEXT;
00580       PFNWGLQUERYFRAMELOCKMASTEREXTPROC           wglQueryFrameLockMasterEXT;
00581
00582       //  WGL_I3D_genlock functions
00583       PFNWGLENABLEGENLOCKI3DPROC                  wglEnableGenlockI3D;
00584       PFNWGLDISABLEGENLOCKI3DPROC                 wglDisableGenlockI3D;
00585       PFNWGLISENABLEDGENLOCKI3DPROC               wglIsEnabledGenlockI3D;
00586       PFNWGLGENLOCKSOURCEI3DPROC                  wglGenlockSourceI3D;
00587       PFNWGLGETGENLOCKSOURCEI3DPROC               wglGetGenlockSourceI3D;
00588       PFNWGLGENLOCKSOURCEEDGEI3DPROC              wglGenlockSourceEdgeI3D;
00589       PFNWGLGETGENLOCKSOURCEEDGEI3DPROC           wglGetGenlockSourceEdgeI3D;
00590       PFNWGLGENLOCKSAMPLERATEI3DPROC              wglGenlockSampleRateI3D;
00591       PFNWGLGETGENLOCKSAMPLERATEI3DPROC           wglGetGenlockSampleRateI3D;
00592       PFNWGLGENLOCKSOURCEDELAYI3DPROC             wglGenlockSourceDelayI3D;
00593       PFNWGLGETGENLOCKSOURCEDELAYI3DPROC          wglGetGenlockSourceDelayI3D;
00594       PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC     wglQueryGenlockMaxSourceDelayI3D;
00595
00596       //  WGL_KTX_buffer_region functions
00597       PFNWGLNEWBUFFERREGIONPROC                   wglNewBufferRegion;
00598       PFNWGLDELETEBUFFERREGIONPROC                wglDeleteBufferRegion;
00599       PFNWGLREADBUFFERREGIONPROC                  wglReadBufferRegion;
00600       PFNWGLDRAWBUFFERREGIONPROC                  wglDrawBufferRegion;
00601       PFNWGLBUFFERREGIONENABLEDPROC               wglBufferRegionEnabled;
00602
00603       //  WGL_NV_allocate_memory functions
00604       PFNWGLALLOCATEMEMORYNVPROC                  wglAllocateMemoryNV;
00605       PFNWGLFREEMEMORYNVPROC                      wglFreeMemoryNV;
00606
00607       //  WGL_NV_swap_group functions
00608       PFNWGLBINDSWAPBARRIERNVPROC                 wglBindSwapBarrierNV;
00609       PFNWGLJOINSWAPGROUPNVPROC                   wglJoinSwapGroupNV;
00610       PFNWGLQUERYSWAPGROUPNVPROC                  wglQuerySwapGroupNV;
00611       PFNWGLQUERYMAXSWAPGROUPSNVPROC              wglQueryMaxSwapGroupsNV;
00612       PFNWGLQUERYFRAMECOUNTNVPROC                 wglQueryFrameCountNV;
00613       PFNWGLRESETFRAMECOUNTNVPROC                 wglResetFrameCountNV;
00614 #elif defined(LINUX)
00615       PFNGLXQUERYEXTENSIONSSTRINGPROC             glXQueryExtensionsString;
00616
00617       // GLX_SGIX_pbuffer
00618       PFNGLXCREATEGLXPBUFFERSGIXPROC              glXCreateGLXPbufferSGIX;
00619       PFNGLXDESTROYGLXPBUFFERSGIXPROC             glXDestroyGLXPbufferSGIX;
00620       PFNGLXQUERYGLXPBUFFERSGIXPROC               glXQueryGLXPbufferSGIX;
00621 #endif
00622 #endif  //  DOXYGEN_IGNORE
00623
00624     private:
00625       int         m_glVersion;
00626       std::set<std::string> m_available;
00627       std::set<std::string> m_exported;
00628   };
00629
00630   inline  bool  GLFunctions::isAvailable( const std::string& extension ) const
00631   {
00632     return( m_available.find( extension ) != m_available.end() );
00633   }
00634
00635   inline  bool   GLFunctions::isExported( const std::string& extension ) const
00636   {
00637     return( m_exported.find( extension ) != m_exported.end() );
00638   }
00639 }
Generated on Fri Aug 4 08:33:03 2006 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

Defines

#define | RAMFC_API __declspec(dllimport)

Detailed Description

Generated on Fri Aug 4 08:33:45 2006 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 #ifdef RAMFC_EXPORTS
00019 # define RAMFC_API __declspec(dllexport)
00020 #else
00021 # define RAMFC_API __declspec(dllimport)
00022 #endif
00023
00024
00025 namespace nvui
00026 {
00028
00031   class GLMFCRAWnd :  public CWnd, public GLWinRenderArea
00032   {
00033     public:
00035       RAMFC_API GLMFCRAWnd(void);
00037       RAMFC_API virtual ~GLMFCRAWnd(void);
00038
00040
00042       RAMFC_API virtual bool init( RenderArea * shareArea = NULL
00043                                    );
00044
00045       RAMFC_API afx_msg BOOL  OnEraseBkgnd( CDC* pDC );
00046       RAMFC_API afx_msg void  OnPaint( void );
00047
00049
00051       RAMFC_API virtual void setViewportSize( size_t x
00052                                            , size_t y
00053                                            );
00054
00056
00058       RAMFC_API virtual void destroy();
00059
00061
00062       RAMFC_API virtual void triggerRedraw();
00063
00064     protected:
00065       RAMFC_API virtual BOOL  PreCreateWindow( CREATESTRUCT& cs );
00066
00067       DECLARE_MESSAGE_MAP()
00068   };
00069
00070 } //  namespace nvui
00071
00072
00073 #endif //_WIN32
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:33:46 2006 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   struct GLDALDataCreator;
00025
00027
00030   class GLObjects
00031   {
00032     friend class GLContext;
00033
00034     public:
00036       GLObjects();
00038       ~GLObjects();
00039
00040     public:
00042       void addBuffers(GLsizei n, const GLuint * names);
00043
00045       void removeBuffers(GLsizei n, const GLuint * names);
00046
00048       void addLists(GLsizei n, GLuint first);
00049
00051       void removeLists(GLsizei n, GLuint first);
00052
00054       void addPrograms(GLsizei n, const GLuint * names);
00055
00057       void removePrograms(GLsizei n, const GLuint * names);
00058
00060       void addTextures(GLsizei n, const GLuint * names);
00061
00063       void removeTextures(GLsizei n, const GLuint * names);
00064
00066       void addOcclusionQueries(GLsizei n, const GLuint * names);
00067
00069       void removeOcclusionQueries(GLsizei n, const GLuint * names);
00070
00072       void addQueries(GLsizei n, const GLuint * names);
00073
00075       void removeQueries(GLsizei n, const GLuint * names);
00076
00077     private:
00078       // Collection of shareable objects
00079       struct GLShareables : public nvutil::RCObject
00080       {
00081         GLShareables();
00082         ~GLShareables(); // for cleanup purposes
00083         void exit(); // cleanup
00084
00085         std::set<GLuint> m_vboNames;
00086         std::set<GLuint> m_dlistNames;
00087         std::set<GLuint> m_programNames;
00088         std::set<GLuint> m_textureNames;
00089
00090         GLDALDataCreator * m_DALDataCreator;
00091       };
00092
00093       // shareable objects
00094       GLShareables * m_shareables;
00095       // non-shareable objects
00096       std::set<GLuint> m_occlusionQueryNames;
00097       std::set<GLuint> m_queryNames;
00098   };
00099
00100   inline void GLObjects::addBuffers(GLsizei n, const GLuint * names)
00101   {
00102     NVSG_ASSERT(n>0 && names);
00103     m_shareables->m_vboNames.insert(&names[0], &names[n]);
00104   }
00105
00106   inline void GLObjects::removeBuffers(GLsizei n, const GLuint * names)
00107   {
00108     NVSG_ASSERT(n>0 && names);
00109     for( GLsizei i=0; i<n; ++i )
00110     {
00111       m_shareables->m_vboNames.erase(names[i]);
00112     }
00113   }
00114
00115   inline void GLObjects::addLists(GLsizei n, GLuint first)
00116   {
00117     NVSG_ASSERT(n>0 && first>0);
00118     for( GLuint i=first; i<first+n; ++i )
00119     {
00120       m_shareables->m_dlistNames.insert(i);
00121     }
00122   }
00123
00124   inline void GLObjects::removeLists(GLsizei n, GLuint first)
00125   {
00126     NVSG_ASSERT(n>0 && first>0);
00127     for( GLuint i=first; i<first+n; ++i )
00128     {
00129       m_shareables->m_dlistNames.erase(i);
00130     }
00131   }
00132
00133   inline void GLObjects::addPrograms(GLsizei n, const GLuint * names)
00134   {
00135     NVSG_ASSERT(n>0 && names);
00136     m_shareables->m_programNames.insert(&names[0], &names[n]);
00137   }
00138
00139   inline void GLObjects::removePrograms(GLsizei n, const GLuint * names)
00140   {
00141     NVSG_ASSERT(n>0 && names);
00142     for( GLsizei i=0; i<n; ++i )
00143     {
00144       m_shareables->m_programNames.erase(names[i]);
00145     }
00146   }
00147
00148   inline void GLObjects::addTextures(GLsizei n, const GLuint * names)
00149   {
00150     NVSG_ASSERT(n>0 && names);
00151     m_shareables->m_textureNames.insert(&names[0], &names[n]);
00152   }
00153
00154   inline void GLObjects::removeTextures(GLsizei n, const GLuint * names)
00155   {
00156     NVSG_ASSERT(n>0 && names);
00157     for( GLsizei i=0; i<n; ++i )
00158     {
00159       m_shareables->m_textureNames.erase(names[i]);
00160     }
00161   }
00162
00163   inline void GLObjects::addOcclusionQueries(GLsizei n, const GLuint * names)
00164   {
00165     NVSG_ASSERT(n>0 && names);
00166     m_occlusionQueryNames.insert(&names[0], &names[n]);
00167   }
00168
00169   inline void GLObjects::removeOcclusionQueries(GLsizei n, const GLuint * names)
00170
00171   {
00172     NVSG_ASSERT(n>0 && names);
00173     for( GLsizei i=0; i<n; ++i )
00174     {
00175       m_occlusionQueryNames.erase(names[i]);
00176     }
00177   }
00178
00179   inline void GLObjects::addQueries(GLsizei n, const GLuint * names)
00180   {
00181     NVSG_ASSERT(n>0 && names);
00182     m_queryNames.insert(&names[0], &names[n]);
00183   }
00184
00185   inline void GLObjects::removeQueries(GLsizei n, const GLuint * names)
00186
00187   {
00188     NVSG_ASSERT(n>0 && names);
00189     for( GLsizei i=0; i<n; ++i )
00190     {
00191       m_queryNames.erase(names[i]);
00192     }
00193   }
00194
00195 } //  namespace nvgl
Generated on Fri Aug 4 08:33:03 2006 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.

Defines

#define | NVSG_GL_STATS_FCT_COUNT()
#define | NVSG_GL_STATS_ACTIVE_TEXTURE(texture)
#define | NVSG_GL_STATS_BIND_BUFFER(target, id)
#define | NVSG_GL_STATS_BIND_TEXTURE(target, texture)
#define | NVSG_GL_STATS_BLEND_FUNC(sfactor, dfactor)
#define | NVSG_GL_STATS_BUFFER_DATA(target, size, data, usage)
#define | NVSG_GL_STATS_CALL_LIST(list)
#define | NVSG_GL_STATS_CLEAR(mask)
#define | NVSG_GL_STATS_CLEAR_COLOR(red, green, blue, alpha)
#define | NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE(texture)
#define | NVSG_GL_STATS_CLIENT_STATE(array, on)
#define | NVSG_GL_STATS_COLOR3B(red, green, blue)
#define | NVSG_GL_STATS_COLOR3BV(v)
#define | NVSG_GL_STATS_COLOR3D(red, green, blue)
#define | NVSG_GL_STATS_COLOR3DV(v)
#define | NVSG_GL_STATS_COLOR3F(red, green, blue)
#define | NVSG_GL_STATS_COLOR3FV(v)
#define | NVSG_GL_STATS_COLOR3I(red, green, blue)
#define | NVSG_GL_STATS_COLOR3IV(v)
#define | NVSG_GL_STATS_COLOR3S(red, green, blue)
#define | NVSG_GL_STATS_COLOR3SV(v)
#define | NVSG_GL_STATS_COLOR3UB(red, green, blue)
#define | NVSG_GL_STATS_COLOR3UBV(v)
#define | NVSG_GL_STATS_COLOR3UI(red, green, blue)
#define | NVSG_GL_STATS_COLOR3UIV(v)
#define | NVSG_GL_STATS_COLOR3US(red, green, blue)
#define | NVSG_GL_STATS_COLOR3USV(v)
#define | NVSG_GL_STATS_COLOR4B(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4BV(v)
#define | NVSG_GL_STATS_COLOR4D(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4DV(v)
#define | NVSG_GL_STATS_COLOR4F(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4FV(v)
#define | NVSG_GL_STATS_COLOR4I(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4IV(v)
#define | NVSG_GL_STATS_COLOR4S(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4SV(v)
#define | NVSG_GL_STATS_COLOR4UB(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4UBV(v)
#define | NVSG_GL_STATS_COLOR4UI(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4UIV(v)
#define | NVSG_GL_STATS_COLOR4US(red, green, blue, alpha)
#define | NVSG_GL_STATS_COLOR4USV(v)
#define | NVSG_GL_STATS_DELETE_BUFFERS(n, buffers)
#define | NVSG_GL_STATS_DELETE_LISTS(list, range)
#define | NVSG_GL_STATS_DELETE_TEXTURES(n, textures)
#define | NVSG_GL_STATS_DEPTH_FUNC(func)
#define | NVSG_GL_STATS_DEPTH_MASK(flag)
#define | NVSG_GL_STATS_DRAW_ELEMENTS(mode, count, type, indices)
#define | NVSG_GL_STATS_DRAW_RANGE_ELEMENTS(mode, start, end, count, type, indices)
#define | NVSG_GL_STATS_END_LIST()
#define | NVSG_GL_STATS_FRUSTUM(left, right, bottom, top, zNear, zFar)
#define | NVSG_GL_STATS_GEN_BUFFERS(n, buffers)
#define | NVSG_GL_STATS_GEN_LISTS(range)
#define | NVSG_GL_STATS_GEN_TEXTURES(n, textures)
#define | NVSG_GL_STATS_GET_INTEGERV(pname, params)
#define | NVSG_GL_STATS_IS_TEXTURE(texture)
#define | NVSG_GL_STATS_LIGHTF(light, pname, param)
#define | NVSG_GL_STATS_LIGHTFV(light, pname, params)
#define | NVSG_GL_STATS_LIGHTI(light, pname, param)
#define | NVSG_GL_STATS_LIGHTIV(light, pname, params)
#define | NVSG_GL_STATS_LIGHT_MODELF(pname, param)
#define | NVSG_GL_STATS_LIGHT_MODELFV(pname, params)
#define | NVSG_GL_STATS_LIGHT_MODELI(pname, param)
#define | NVSG_GL_STATS_LIGHT_MODELIV(pname, params)
#define | NVSG_GL_STATS_LINE_WIDTH(width)
#define | NVSG_GL_STATS_LOAD_IDENTITY()
#define | NVSG_GL_STATS_LOAD_MATRIXD(m)
#define | NVSG_GL_STATS_LOAD_MATRIXF(m)
#define | NVSG_GL_STATS_MATERIALF(face, pname, param)
#define | NVSG_GL_STATS_MATERIALFV(face, pname, params)
#define | NVSG_GL_STATS_MATERIALI(face, pname, param)
#define | NVSG_GL_STATS_MATERIALIV(face, pname, params)
#define | NVSG_GL_STATS_MATRIX_MODE(mode)
#define | NVSG_GL_STATS_MULT_MATRIXD(m)
#define | NVSG_GL_STATS_MULT_MATRIXF(m)
#define | NVSG_GL_STATS_NEW_LIST(list, mode)
#define | NVSG_GL_STATS_NORMAL_POINTER(type, stride, pointer)
#define | NVSG_GL_STATS_ORTHO(left, right, bottom, top, zNear, zFar)
#define | NVSG_GL_STATS_POINT_SIZE(size)
#define | NVSG_GL_STATS_POLYGON_MODE(face, mode)
#define | NVSG_GL_STATS_POLYGON_OFFSET(factor, units)
#define | NVSG_GL_STATS_POP_ATTRIB()
#define | NVSG_GL_STATS_POP_MATRIX()
#define | NVSG_GL_STATS_PRIMITIVE_RESTART_INDEX(index)
#define | NVSG_GL_STATS_PUSH_ATTRIB(mask)
#define | NVSG_GL_STATS_PUSH_MATRIX()
#define | NVSG_GL_STATS_ROTATED(angle, x, y, z)
#define | NVSG_GL_STATS_ROTATEF(angle, x, y, z)
#define | NVSG_GL_STATS_SCALED(x, y, z)
#define | NVSG_GL_STATS_SCALEF(x, y, z)
#define | NVSG_GL_STATS_STATE(cap, on)
#define | NVSG_GL_STATS_TEX_COORD_POINTER(size, type, stride, pointer)
#define | NVSG_GL_STATS_TEX_ENVF(target, pname, param)
#define | NVSG_GL_STATS_TEX_ENVFV(target, pname, params)
#define | NVSG_GL_STATS_TEX_ENVI(target, pname, param)
#define | NVSG_GL_STATS_TEX_ENVIV(target, pname, params)
#define | NVSG_GL_STATS_TEX_IMAGE2D(target, level, internalformat, width, height, border, format, type, pixels)
#define | NVSG_GL_STATS_TEX_PARAMETERF(target, pname, param)
#define | NVSG_GL_STATS_TEX_PARAMETERFV(target, pname, params)
#define | NVSG_GL_STATS_TEX_PARAMETERI(target, pname, param)
#define | NVSG_GL_STATS_TEX_PARAMETERIV(target, pname, params)
#define | NVSG_GL_STATS_TRANSLATED(x, y, z)
#define | NVSG_GL_STATS_TRANSLATEF(x, y, z)
#define | NVSG_GL_STATS_VERTEX_POINTER(size, type, stride, pointer)
#define | NVSG_GL_STATS_VIEWPORT(x, y, width, height)

Detailed Description

Generated on Fri Aug 4 08:33:47 2006 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(NDEBUG)
00018 //# define GL_STATISTICS
00019 //#endif
00020
00021 #if defined( GL_STATISTICS )
00022
00023 #include "nvgl/nvgl.h"
00024 #include "nvmath/Mat44f.h"
00025 #include "nvmath/Vec3f.h"
00026 #include "nvmath/Vec4f.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, pixels )
00129 # define  NVSG_GL_STATS_TEX_PARAMETERF( target, pname, param )           glContext()->m_glStats->texParameterf( __FUNCTION__, target, pname, param )
00130 # define  NVSG_GL_STATS_TEX_PARAMETERFV( target, pname, params )         glContext()->m_glStats->texParameterfv( __FUNCTION__, target, pname, params )
00131 # define  NVSG_GL_STATS_TEX_PARAMETERI( target, pname, param )           glContext()->m_glStats->texParameteri( __FUNCTION__, target, pname, param )
00132 # define  NVSG_GL_STATS_TEX_PARAMETERIV( target, pname, params )         glContext()->m_glStats->texParameteriv( __FUNCTION__, target, pname, params )
00133 # define  NVSG_GL_STATS_TRANSLATED( x, y, z )                            glContext()->m_glStats->translated( __FUNCTION__, x, y, z )
00134 # define  NVSG_GL_STATS_TRANSLATEF( x, y, z )                            glContext()->m_glStats->translatef( __FUNCTION__, x, y, z )
00135 # define  NVSG_GL_STATS_VERTEX_POINTER( size, type, stride, pointer )    glContext()->m_glStats->vertexPointer( __FUNCTION__, size, type, stride, pointer )
00136 # define  NVSG_GL_STATS_VIEWPORT( x, y, width, height )                  glContext()->m_glStats->viewport( __FUNCTION__, x, y, width, height )
00137
00138
00139 class GLStatsEnable
00140 {
00141 public:
00142   GLStatsEnable( void )
00143     : enableState(false)
00144     , enableCalls(0)
00145     , disableCalls(0)
00146     , redundantEnables(0)
00147     , redundantDisables(0)
00148   {
00149   }
00150
00151 public:
00152   bool    enableState;
00153   size_t  enableCalls;
00154   size_t  disableCalls;
00155   size_t  redundantEnables;
00156   size_t  redundantDisables;
00157 };
00158
00159 class GLStatsCount
00160 {
00161 public:
00162   GLStatsCount( void )
00163     : calls(0)
00164     , redundantCalls(0)
00165   {
00166   }
00167
00168 public:
00169   size_t  calls;
00170   size_t  redundantCalls;
00171 };
00172
00173 class GLStatsFloat : public GLStatsCount
00174 {
00175 public:
00176   GLStatsFloat( void )
00177     : value(-1.0f)
00178   {
00179   }
00180
00181 public:
00182   float   value;
00183 };
00184
00185 class GLStatsVec3f : public GLStatsCount
00186 {
00187 public:
00188   GLStatsVec3f( void )
00189     : value( -1.0f, -1.0f, -1.0f )
00190   {
00191   }
00192
00193 public:
00194   nvmath::Vec3f value;
00195 };
00196
00197 class GLStatsVec4f : public GLStatsCount
00198 {
00199 public:
00200   GLStatsVec4f( void )
00201     : value( -1.0f, -1.0f, -1.0f, -1.0f )
00202   {
00203   }
00204
00205 public:
00206   nvmath::Vec4f value;
00207 };
00208
00209 class GLStatistics
00210 {
00211 public:
00212   GLStatistics( void );
00213
00214   void  dump( void );
00215   void  dumpHistogram( FILE *fh, const std::map<size_t,size_t> &hist, char *prefix );
00216   void  activeTexture( const char *fctName, GLenum texture );
00217   void  bindBuffer( const char *fctName, GLenum target, GLuint id );
00218   void  bindTexture( const char *fctName, GLenum target, GLuint texture );
00219   void  blendFunc( const char *fctName, GLenum sfactor, GLenum dfactor );
00220   void  bufferData( const char *fctName, GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage );
00221   void  callList( const char *fctName, GLuint list );
00222   void  clear( const char *fctName, GLbitfield mask );
00223   void  clearColor( const char *fctName, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
00224   void  clientActiveTexture( const char *fctName, GLenum texture );
00225   void  clientState( const char *fctName, GLenum array, bool enable );
00226   void  color3b( const char *fctName, GLbyte red, GLbyte green, GLbyte blue );
00227   void  color3bv( const char *fctName, const GLbyte *v );
00228   void  color3d( const char *fctName, GLdouble red, GLdouble green, GLdouble blue );
00229   void  color3dv( const char *fctName, const GLdouble *v );
00230   void  color3f( const char *fctName, GLfloat red, GLfloat green, GLfloat blue );
00231   void  color3fv( const char *fctName, const GLfloat *v );
00232   void  color3i( const char *fctName, GLint red, GLint green, GLint blue );
00233   void  color3iv( const char *fctName, const GLint *v );
00234   void  color3s( const char *fctName, GLshort red, GLshort green, GLshort blue );
00235   void  color3sv( const char *fctName, const GLshort *v );
00236   void  color3ub( const char *fctName, GLubyte red, GLubyte green, GLubyte blue );
00237   void  color3ubv( const char *fctName, const GLubyte *v );
00238   void  color3ui( const char *fctName, GLuint red, GLuint green, GLuint blue );
00239   void  color3uiv( const char *fctName, const GLuint *v );
00240   void  color3us( const char *fctName, GLushort red, GLushort green, GLushort blue );
00241   void  color3usv( const char *fctName, const GLushort *v );
00242   void  color4b( const char *fctName, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha );
00243   void  color4bv( const char *fctName, const GLbyte *v );
00244   void  color4d( const char *fctName, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha );
00245   void  color4dv( const char *fctName, const GLdouble *v );
00246   void  color4f( const char *fctName, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
00247   void  color4fv( const char *fctName, const GLfloat *v );
00248   void  color4i( const char *fctName, GLint red, GLint green, GLint blue, GLint alpha );
00249   void  color4iv( const char *fctName, const GLint *v );
00250   void  color4s( const char *fctName, GLshort red, GLshort green, GLshort blue, GLshort alpha );
00251   void  color4sv( const char *fctName, const GLshort *v );
00252   void  color4ub( const char *fctName, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
00253   void  color4ubv( const char *fctName, const GLubyte *v );
00254   void  color4ui( const char *fctName, GLuint red, GLuint green, GLuint blue, GLuint alpha );
00255   void  color4uiv( const char *fctName, const GLuint *v );
00256   void  color4us( const char *fctName, GLushort red, GLushort green, GLushort blue, GLushort alpha );
00257   void  color4usv( const char *fctName, const GLushort *v );
00258   void  deleteBuffers( const char *fctName, GLsizei n, const GLuint *buffers );
00259   void  deleteLists( const char *fctName, GLuint list, GLsizei range );
00260   void  deleteTextures( const char *fctName, GLsizei n, const GLuint *textures );
00261   void  depthFunc( const char *fctName, GLenum func );
00262   void  depthMask( const char *fctName, GLboolean flag );
00263   void  drawElements( const char *fctName, GLenum mode, GLsizei count, GLenum type, const GLvoid *indices );
00264   void  drawRangeElements( const char *fctName, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
00265   void  endList( const char *fctName );
00266   void  frustum( const char *fctName, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
00267   void  initLightDefault( GLenum light, GLenum pname );
00268   void  initLightModelDefault( GLenum pname );
00269   void  initMaterialDefault( GLenum face, GLenum pname );
00270   void  initMatrixDefault( void );
00271   void  initPolygonMode( GLenum face );
00272   void  initStateDefault( GLenum cap );
00273   void  initTexEnv( GLenum target, GLenum pname );
00274   void  initTexParameter( GLenum target, GLenum pname );
00275   void  genBuffers( const char *fctName, GLsizei n, GLuint *buffers );
00276   void  genLists( const char *fctName, GLsizei range );
00277   void  genTextures( const char *fctName, GLsizei n, GLuint *textures );
00278   void  getIntegerv( const char *fctName, GLenum pname, GLint *params );
00279   void  isTexture( const char *fctName, GLuint texture );
00280   void  lightf( const char *fctName, GLenum light, GLenum pname, GLfloat param );
00281   void  lightfv( const char *fctName, GLenum light, GLenum pname, const GLfloat *params );
00282   void  lighti( const char *fctName, GLenum light, GLenum pname, GLint param );
00283   void  lightiv( const char *fctName, GLenum light, GLenum pname, const GLint *params );
00284   void  lightModelf( const char *fctName, GLenum pname, GLfloat param );
00285   void  lightModelfv( const char *fctName, GLenum pname, const GLfloat *params );
00286   void  lightModeli( const char *fctName, GLenum pname, GLint param );
00287   void  lightModeliv( const char *fctName, GLenum pname, const GLint *params );
00288   void  lineWidth( const char *fctName, GLfloat width );
00289   void  loadIdentity( const char *fctName );
00290   void  loadMatrixd( const char *fctName, const GLdouble *m );
00291   void  loadMatrixf( const char *fctName, const GLfloat *m );
00292   void  materialf( const char *fctName, GLenum face, GLenum pname, GLfloat param );
00293   void  materialfv( const char *fctName, GLenum face, GLenum pname, const GLfloat *params );
00294   void  materiali( const char *fctName, GLenum face, GLenum pname, GLint param );
00295   void  materialiv( const char *fctName, GLenum face, GLenum pname, const GLint *params );
00296   void  matrixMode( const char *fctName, GLenum mode );
00297   void  multMatrixd( const char *fctName, const GLdouble *m );
00298   void  multMatrixf( const char *fctName, const GLfloat *m );
00299   void  newList( const char *fctName, GLuint list, GLenum mode );
00300   void  normalPointer( const char *fctName, GLenum type, GLsizei stride, const GLvoid *pointer );
00301   void  ortho( const char *fctName, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear
00302              , GLdouble zFar );
00303   void  pointSize( const char *fctName, GLfloat size );
00304   void  polygonMode( const char *fctName, GLenum face, GLenum mode );
00305   void  polygonOffset( const char *fctName, GLfloat factor, GLfloat units );
00306   void  popAttrib( const char *fctName );
00307   void  popMatrix( const char *fctName );
00308   void  primitiveRestartIndex( const char *fctName, GLuint index );
00309   void  pushAttrib( const char *fctName, GLbitfield mask );
00310   void  pushMatrix( const char *fctName );
00311   void  rotated( const char *fctName , GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
00312   void  rotatef( const char *fctName , GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
00313   void  scaled( const char *fctName, GLdouble x, GLdouble y, GLdouble z );
00314   void  scalef( const char *fctName, GLfloat x, GLfloat y, GLfloat z );
00315   void  state( const char *fctName, GLenum cap, bool on );
00316   void  texCoordPointer( const char *fctName, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00317   void  texEnvf( const char *fctName, GLenum target, GLenum pname, GLfloat param );
00318   void  texEnvfv( const char *fctName, GLenum target, GLenum pname, const GLfloat *params );
00319   void  texEnvi( const char *fctName, GLenum target, GLenum pname, GLint param );
00320   void  texEnviv( const char *fctName, GLenum target, GLenum pname, const GLint *params );
00321   void  texImage2d( const char *fctName, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height
00322                   , GLint border, GLenum format, GLenum type, const GLvoid *pixels );
00323   void  texParameterf( const char *fctName, GLenum target, GLenum pname, GLfloat param );
00324   void  texParameterfv( const char *fctName, GLenum target, GLenum pname, const GLfloat *params );
00325   void  texParameteri( const char *fctName, GLenum target, GLenum pname, GLint param );
00326   void  texParameteriv( const char *fctName, GLenum target, GLenum pname, const GLint *params );
00327   void  translated( const char *fctName, GLdouble x, GLdouble y, GLdouble z );
00328   void  translatef( const char *fctName, GLfloat x, GLfloat y, GLfloat z );
00329   void  vertexPointer( const char *fctName, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer );
00330   void  viewport( const char *fctName, GLint x, GLint y, GLsizei width, GLsizei height );
00331
00332 public:
00333   std::map<std::string,size_t>                        m_fctCount;
00334   std::map<std::string,GLStatsCount>                  m_fctStats;
00335   GLenum                                              m_activeTexture;
00336   GLenum                                              m_blendFuncDFactor;
00337   GLenum                                              m_blendFuncSFactor;
00338   std::map<GLenum,GLuint>                             m_boundBuffer;
00339   std::vector<std::map<GLenum,GLuint> >               m_boundTexture;
00340   std::map<GLuint,std::vector<char> >                 m_bufferData;
00341   std::map<GLuint,GLenum>                             m_bufferDataUsage;
00342   nvmath::Vec4f                                       m_clearColor;
00343   GLenum                                              m_clientActiveTexture;
00344   nvmath::Vec4f                                       m_color;
00345   GLenum                                              m_depthFunc;
00346   GLboolean                                           m_depthMask;
00347   std::map<size_t,size_t>                             m_drawElementsHistogram;
00348   std::map<size_t,size_t>                             m_drawElementsIndexDistanceHistogram;
00349   std::map<GLenum,std::map<GLenum,GLfloat> >          m_lightf;
00350   std::map<GLenum,std::map<GLenum,nvmath::Vec3f> >    m_light3f;
00351   std::map<GLenum,std::map<GLenum,nvmath::Vec4f> >    m_light4f;
00352   std::map<GLenum,nvmath::Vec4f>                      m_lightModel4f;
00353   std::map<GLenum,GLint>                              m_lightModeli;
00354   GLfloat                                             m_lineWidth;
00355   std::map<GLenum,std::map<GLenum,GLfloat> >          m_materialf;
00356   std::map<GLenum,std::map<GLenum,nvmath::Vec4f> >    m_material4f;
00357   std::map<GLenum,std::stack<nvmath::Mat44f> >        m_matrixf;
00358   GLenum                                              m_matrixMode;
00359   GLfloat                                             m_pointSize;
00360   std::map<GLenum,GLenum>                             m_polygonMode;
00361   GLfloat                                             m_polygonOffsetFactor;
00362   GLfloat                                             m_polygonOffsetUnits;
00363   GLuint                                              m_primitiveRestartIndex;
00364   std::map<GLenum,bool>                               m_state;
00365   std::map<GLuint,std::map<GLint,GLint> >             m_texImage2dInternalFormat;
00366   std::map<GLuint,std::map<GLenum,GLint> >            m_texParameter;
00367   std::map<GLuint,nvmath::Vec4f>                      m_textureBorderColor;
00368   std::map<GLenum,bool>                               m_textureCoordArrayState;
00369   std::map<GLenum,nvmath::Vec4f>                      m_textureEnvColor;
00370   std::map<GLenum,GLint>                              m_textureEnvMode;
00371   std::map<GLuint,GLfloat>                            m_texturePriority;
00372   GLsizei                                             m_viewportHeight;
00373   GLsizei                                             m_viewportWidth;
00374   GLint                                               m_viewportX;
00375   GLint                                               m_viewportY;
00376 };
00377
00378 #else
00379
00380 # define  NVSG_GL_STATS_FCT_COUNT()
00381 # define  NVSG_GL_STATS_ACTIVE_TEXTURE( texture )
00382 # define  NVSG_GL_STATS_BIND_BUFFER( target, id )
00383 # define  NVSG_GL_STATS_BIND_TEXTURE( target, texture )
00384 # define  NVSG_GL_STATS_BLEND_FUNC( sfactor, dfactor )
00385 # define  NVSG_GL_STATS_BUFFER_DATA( target, size, data, usage )
00386 # define  NVSG_GL_STATS_CALL_LIST( list )
00387 # define  NVSG_GL_STATS_CLEAR( mask )
00388 # define  NVSG_GL_STATS_CLEAR_COLOR( red, green, blue, alpha )
00389 # define  NVSG_GL_STATS_CLIENT_ACTIVE_TEXTURE( texture )
00390 # define  NVSG_GL_STATS_CLIENT_STATE( array, on )
00391 # define  NVSG_GL_STATS_COLOR3B( red, green, blue )
00392 # define  NVSG_GL_STATS_COLOR3BV( v )
00393 # define  NVSG_GL_STATS_COLOR3D( red, green, blue )
00394 # define  NVSG_GL_STATS_COLOR3DV( v )
00395 # define  NVSG_GL_STATS_COLOR3F( red, green, blue )
00396 # define  NVSG_GL_STATS_COLOR3FV( v )
00397 # define  NVSG_GL_STATS_COLOR3I( red, green, blue )
00398 # define  NVSG_GL_STATS_COLOR3IV( v )
00399 # define  NVSG_GL_STATS_COLOR3S( red, green, blue )
00400 # define  NVSG_GL_STATS_COLOR3SV( v )
00401 # define  NVSG_GL_STATS_COLOR3UB( red, green, blue )
00402 # define  NVSG_GL_STATS_COLOR3UBV( v )
00403 # define  NVSG_GL_STATS_COLOR3UI( red, green, blue )
00404 # define  NVSG_GL_STATS_COLOR3UIV( v )
00405 # define  NVSG_GL_STATS_COLOR3US( red, green, blue )
00406 # define  NVSG_GL_STATS_COLOR3USV( v )
00407 # define  NVSG_GL_STATS_COLOR4B( red, green, blue, alpha )
00408 # define  NVSG_GL_STATS_COLOR4BV( v )
00409 # define  NVSG_GL_STATS_COLOR4D( red, green, blue, alpha )
00410 # define  NVSG_GL_STATS_COLOR4DV( v )
00411 # define  NVSG_GL_STATS_COLOR4F( red, green, blue, alpha )
00412 # define  NVSG_GL_STATS_COLOR4FV( v )
00413 # define  NVSG_GL_STATS_COLOR4I( red, green, blue, alpha )
00414 # define  NVSG_GL_STATS_COLOR4IV( v )
00415 # define  NVSG_GL_STATS_COLOR4S( red, green, blue, alpha )
00416 # define  NVSG_GL_STATS_COLOR4SV( v )
00417 # define  NVSG_GL_STATS_COLOR4UB( red, green, blue, alpha )
00418 # define  NVSG_GL_STATS_COLOR4UBV( v )
00419 # define  NVSG_GL_STATS_COLOR4UI( red, green, blue, alpha )
00420 # define  NVSG_GL_STATS_COLOR4UIV( v )
00421 # define  NVSG_GL_STATS_COLOR4US( red, green, blue, alpha )
00422 # define  NVSG_GL_STATS_COLOR4USV( v )
00423 # define  NVSG_GL_STATS_DELETE_BUFFERS( n, buffers )
00424 # define  NVSG_GL_STATS_DELETE_LISTS( list, range )
00425 # define  NVSG_GL_STATS_DELETE_TEXTURES( n, textures )
00426 # define  NVSG_GL_STATS_DEPTH_FUNC( func )
00427 # define  NVSG_GL_STATS_DEPTH_MASK( flag )
00428 # define  NVSG_GL_STATS_DRAW_ELEMENTS( mode, count, type, indices )
00429 # define  NVSG_GL_STATS_DRAW_RANGE_ELEMENTS( mode, start, end, count, type, indices )
00430 # define  NVSG_GL_STATS_END_LIST()
00431 # define  NVSG_GL_STATS_FRUSTUM( left, right, bottom, top, zNear, zFar )
00432 # define  NVSG_GL_STATS_GEN_BUFFERS( n, buffers )
00433 # define  NVSG_GL_STATS_GEN_LISTS( range )
00434 # define  NVSG_GL_STATS_GEN_TEXTURES( n, textures )
00435 # define  NVSG_GL_STATS_GET_INTEGERV( pname, params )
00436 # define  NVSG_GL_STATS_IS_TEXTURE( texture )
00437 # define  NVSG_GL_STATS_LIGHTF( light, pname, param )
00438 # define  NVSG_GL_STATS_LIGHTFV( light, pname, params )
00439 # define  NVSG_GL_STATS_LIGHTI( light, pname, param )
00440 # define  NVSG_GL_STATS_LIGHTIV( light, pname, params )
00441 # define  NVSG_GL_STATS_LIGHT_MODELF( pname, param )
00442 # define  NVSG_GL_STATS_LIGHT_MODELFV( pname, params )
00443 # define  NVSG_GL_STATS_LIGHT_MODELI( pname, param )
00444 # define  NVSG_GL_STATS_LIGHT_MODELIV( pname, params )
00445 # define  NVSG_GL_STATS_LINE_WIDTH( width )
00446 # define  NVSG_GL_STATS_LOAD_IDENTITY()
00447 # define  NVSG_GL_STATS_LOAD_MATRIXD( m )
00448 # define  NVSG_GL_STATS_LOAD_MATRIXF( m )
00449 # define  NVSG_GL_STATS_MATERIALF( face, pname, param )
00450 # define  NVSG_GL_STATS_MATERIALFV( face, pname, params )
00451 # define  NVSG_GL_STATS_MATERIALI( face, pname, param )
00452 # define  NVSG_GL_STATS_MATERIALIV( face, pname, params )
00453 # define  NVSG_GL_STATS_MATRIX_MODE( mode )
00454 # define  NVSG_GL_STATS_MULT_MATRIXD( m )
00455 # define  NVSG_GL_STATS_MULT_MATRIXF( m )
00456 # define  NVSG_GL_STATS_NEW_LIST( list, mode )
00457 # define  NVSG_GL_STATS_NORMAL_POINTER( type, stride, pointer )
00458 # define  NVSG_GL_STATS_ORTHO( left, right, bottom, top, zNear, zFar )
00459 # define  NVSG_GL_STATS_POINT_SIZE( size )
00460 # define  NVSG_GL_STATS_POLYGON_MODE( face, mode )
00461 # define  NVSG_GL_STATS_POLYGON_OFFSET( factor, units )
00462 # define  NVSG_GL_STATS_POP_ATTRIB()
00463 # define  NVSG_GL_STATS_POP_MATRIX()
00464 # define  NVSG_GL_STATS_PRIMITIVE_RESTART_INDEX( index )
00465 # define  NVSG_GL_STATS_PUSH_ATTRIB( mask )
00466 # define  NVSG_GL_STATS_PUSH_MATRIX()
00467 # define  NVSG_GL_STATS_ROTATED( angle, x, y, z )
00468 # define  NVSG_GL_STATS_ROTATEF( angle, x, y, z )
00469 # define  NVSG_GL_STATS_SCALED( x, y, z )
00470 # define  NVSG_GL_STATS_SCALEF( x, y, z )
00471 # define  NVSG_GL_STATS_STATE( cap, on )
00472 # define  NVSG_GL_STATS_TEX_COORD_POINTER( size, type, stride, pointer )
00473 # define  NVSG_GL_STATS_TEX_ENVF( target, pname, param )
00474 # define  NVSG_GL_STATS_TEX_ENVFV( target, pname, params )
00475 # define  NVSG_GL_STATS_TEX_ENVI( target, pname, param )
00476 # define  NVSG_GL_STATS_TEX_ENVIV( target, pname, params )
00477 # define  NVSG_GL_STATS_TEX_IMAGE2D( target, level, internalformat, width, height, border, format, type, pixels )
00478 # define  NVSG_GL_STATS_TEX_PARAMETERF( target, pname, param )
00479 # define  NVSG_GL_STATS_TEX_PARAMETERFV( target, pname, params )
00480 # define  NVSG_GL_STATS_TEX_PARAMETERI( target, pname, param )
00481 # define  NVSG_GL_STATS_TEX_PARAMETERIV( target, pname, params )
00482 # define  NVSG_GL_STATS_TRANSLATED( x, y, z )
00483 # define  NVSG_GL_STATS_TRANSLATEF( x, y, z )
00484 # define  NVSG_GL_STATS_VERTEX_POINTER( size, type, stride, pointer )
00485 # define  NVSG_GL_STATS_VIEWPORT( x, y, width, height )
00486
00487 #endif
Generated on Fri Aug 4 08:33:03 2006 for NVSGSDK by NVIDIA


GLTraverser.h File Reference

#include <list>
#include "nvsgcommon.h"
#include "nvgl/GLContext.h"
#include "nvmath/Mat44f.h"
#include "nvsg/nvsg.h"
#include "nvgl/GLDALData.h"
#include "nvtraverser/RenderTraverser.h"
#include "nvutil/RCObject.h"

Include dependency graph for GLTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
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 Fri Aug 4 08:33:48 2006 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
00015 #include  <list>
00016
00017 #include "nvsgcommon.h"
00018
00019 #include  "nvgl/GLContext.h"
00020 #include  "nvmath/Mat44f.h"
00021 #include  "nvsg/nvsg.h"
00022 #include  "nvgl/GLDALData.h"
00023 #include  "nvtraverser/RenderTraverser.h"
00024 #include  "nvutil/RCObject.h"
00025
00026 namespace nvsg
00027 {
00028   class CgFxEffect;
00029   class IndependentPrimitiveSet;
00030   class MeshedPrimitiveSet;
00031   class StrippedPrimitiveSet;
00032   class TextureImage;
00033 }
00034
00035 namespace nvgl
00036 {
00037   class PBuffer; // internal class, not meant to be publicly used
00038 }
00039
00040 namespace nvtraverser
00041 {
00043 #if defined(_WIN32) && !defined(NDEBUG)
00044   #define NVSG_ASSERT_CONTEXT() assertContext();
00045 #else
00046   #define NVSG_ASSERT_CONTEXT()
00047 #endif
00048
00050
00053   class GLTraverser : public RenderTraverser
00054   {
00055     public:
00057       NVSG_API GLTraverser(void);
00058
00060
00064       NVSG_API virtual bool isGeometryCacheTechniqueSupported( GeometryCacheTechnique gct
00065                                                              ) const;
00066
00068       NVSG_API virtual void setGeometryCacheTechnique( GeometryCacheTechnique gct
00069                                                      );
00070
00072
00077       NVSG_API virtual bool isJitterTechniqueSupported( JitterTechnique jt
00078                                                       ) const;
00079
00081       NVSG_API virtual void setJitterTechnique( JitterTechnique jt
00082                                               );
00083
00085
00088       NVSG_API virtual bool isRenderTechniqueSupported( RenderTechnique rt
00089                                                       ) const;
00090
00092
00098       NVSG_API virtual bool isShadowTechniqueSupported( ShadowTechnique st
00099                                                       ) const;
00100
00102
00103       NVSG_API virtual void setShadowMapSize( size_t size
00104                                             );
00105
00107
00108       NVSG_API virtual void setShadowTechnique( ShadowTechnique st
00109                                               );
00110
00112
00114       NVSG_API virtual void setTextureSizeLimit( size_t size );
00115
00117
00124       NVSG_API virtual bool isTransparencyTechniqueSupported( TransparencyTechnique tt
00125                                                             ) const;
00126
00128       NVSG_API virtual void setTransparencyTechnique( TransparencyTechnique tt
00129                                                     );
00130
00132
00135       NVSG_API virtual bool isOITTechniqueSupported( OITTechnique ot
00136                                                    ) const;
00137
00139
00140       NVSG_API virtual void setOITTechnique( OITTechnique ot
00141                                            );
00142
00144       NVSG_API virtual void setOITMaxPasses( size_t maxPasses
00145                                            );
00146
00148
00150       NVSG_API void setLocalViewer( bool onOff
00151                                   );
00153
00156       NVSG_API bool isLocalViewerEnabled() const;
00157
00159
00161       NVSG_API void setSeparateSpecularColor( bool onOff
00162                                             );
00163
00165
00168       NVSG_API bool isSeparateSpecularColorEnabled( void ) const;
00169
00170       NVSG_API virtual bool isOcclusionCullingSupported( void ) const;
00171       NVSG_API virtual unsigned int createOcclusionCullID( void );
00172       NVSG_API virtual void   destroyOcclusionCullID( unsigned int id );
00173       NVSG_API virtual unsigned int getOcclusionCullResult( unsigned int id );
00174       NVSG_API virtual void   beginOcclusionCullQuery( unsigned int id );
00175       NVSG_API virtual void   endOcclusionCullQuery( unsigned int id );
00176       NVSG_API virtual void   hiddenBegin( void );
00177       NVSG_API virtual void   hiddenEnd( void );
00178
00179     protected:
00181       NVSG_API virtual ~GLTraverser(void);
00182
00184       NVSG_API virtual void doApply( const nvsg::Scene *pScene );
00185
00187       NVSG_API virtual void doRender( const nvsg::Scene * scene );
00188
00190       NVSG_API virtual void handleBitmap( const nvsg::Bitmap * p );
00191
00193       NVSG_API virtual void handleLines(const nvsg::Lines * p);
00194
00196       NVSG_API virtual void handleLineStrips(const nvsg::LineStrips * p);
00197
00199       NVSG_API virtual void handleMapList( const nvsg::MapList * p );
00200
00202       NVSG_API virtual void handlePoints(const nvsg::Points * p);
00203
00205       NVSG_API virtual void handleQuadMeshes(const nvsg::QuadMeshes * p);
00206
00208       NVSG_API virtual void handleQuads(const nvsg::Quads * p);
00209
00211       NVSG_API virtual void handleQuadStrips(const nvsg::QuadStrips * p);
00212
00214       NVSG_API virtual void handleTriangles(const nvsg::Triangles * p);
00215
00217       NVSG_API virtual void handleTriFans(const nvsg::TriFans * p);
00218
00220       NVSG_API virtual void handleTriStrips(const nvsg::TriStrips * p);
00221
00223       NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *p );
00224
00226
00227       NVSG_API virtual void renderAnimatedQuads( const nvsg::AnimatedQuads *p
00228                                                );
00229
00231
00232       NVSG_API virtual void renderAnimatedTriangles( const nvsg::AnimatedTriangles *p
00233                                                    );
00234
00236
00237       NVSG_API virtual void renderBegin( void );
00238
00240
00241       NVSG_API virtual void renderEnd( void );
00242
00244
00245       NVSG_API virtual void renderBlendAttribute( const nvsg::BlendAttribute *p
00246                                                 , bool enable
00247                                                 );
00248
00250
00251       NVSG_API virtual void renderDepthAttribute( const nvsg::DepthAttribute *p
00252                                                 , bool enable
00253                                                 );
00254
00256
00257       NVSG_API virtual void renderDirectedLight( const nvsg::DirectedLight *p
00258                                                , bool enable
00259                                                );
00260
00262
00263       NVSG_API virtual void renderFaceAttribute( const nvsg::FaceAttribute *p
00264                                                , bool enable
00265                                                );
00266
00268
00269       NVSG_API virtual void renderHighlightBox( const nvsg::HighlightBox * p
00270                                               );
00271
00273
00274       NVSG_API virtual void renderHighlightEdges( const nvsg::HighlightEdges * p
00275                                                 );
00276
00278
00279       NVSG_API virtual void renderLineAttribute( const nvsg::LineAttribute *p
00280                                                , bool enable
00281                                                );
00282
00284
00285       NVSG_API virtual void renderLines( const nvsg::Lines *p
00286                                        );
00287
00289
00290       NVSG_API virtual void renderLineStrips( const nvsg::LineStrips *p
00291                                             );
00292
00294
00295       NVSG_API virtual void renderPointAttribute( const nvsg::PointAttribute *p
00296                                                 , bool enable
00297                                                 );
00298
00300
00301       NVSG_API virtual void renderPoints( const nvsg::Points*p
00302                                         );
00303
00305
00306       NVSG_API virtual void renderMaterial( const nvsg::Material *p
00307                                           , bool enable
00308                                           );
00309
00311
00312       NVSG_API virtual void renderParallelCamera( const nvsg::ParallelCamera *p
00313                                                 );
00314
00316
00317       NVSG_API virtual void renderPerspectiveCamera( const nvsg::PerspectiveCamera *p
00318                                                    );
00319
00321
00322       NVSG_API virtual void renderPointLight( const nvsg::PointLight *p
00323                                             , bool enable
00324                                             );
00325
00327
00328       NVSG_API virtual void renderQuadMeshes( const nvsg::QuadMeshes *p
00329         );
00330
00332
00333       NVSG_API virtual void renderQuads( const nvsg::Quads *p
00334                                        );
00335
00337
00338       NVSG_API virtual void renderQuadStrips( const nvsg::QuadStrips *p
00339                                             );
00340
00342
00343       NVSG_API virtual void renderSkinnedTriangles( const nvsg::SkinnedTriangles *p
00344                                                   );
00345
00347
00348       NVSG_API virtual void renderSpotLight( const nvsg::SpotLight *p
00349                                            , bool enable
00350                                            );
00351
00353
00355       NVSG_API virtual void renderStatePass( const nvsg::StatePass *p
00356                                            );
00357
00359
00360       NVSG_API virtual void renderTextureAttribute( const nvsg::TextureAttribute *p
00361                                                   , bool enable
00362                                                   );
00363
00365
00367       NVSG_API virtual void renderTextureAttributeItem( const nvsg::TextureAttributeItem *p
00368                                                       , size_t tu
00369                                                       );
00370
00372
00373       NVSG_API virtual void renderTriangles( const nvsg::Triangles *p
00374                                            );
00375
00377
00378       NVSG_API virtual void renderTriFans( const nvsg::TriFans *p
00379                                          );
00380
00382
00383       NVSG_API virtual void renderTriStrips( const nvsg::TriStrips *p
00384                                            );
00385
00387
00388       NVSG_API virtual void setClipPlane( size_t index
00389                                         , const nvmath::Plane3f & plane
00390                                         , bool enable
00391                                         );
00392
00394
00396       NVSG_API virtual void setTransforms( const nvmath::Mat44f &modelToWorld
00397                                          , const nvmath::Mat44f &worldToModel
00398                                          , bool needsNormalize
00399                                          , bool needsMirror
00400                                          );
00401
00403
00405       NVSG_API virtual void assignDirectedLightToEffectLight( nvsg::CgFxEffect * effect
00406                                                             , nvsg::CgFxParameter lightParam
00407                                                             , const nvsg::DirectedLight * directedLight
00408                                                             , const nvmath::Mat44f& modelToWorld
00409                                                             );
00410
00412
00414       NVSG_API virtual void assignPointLightToEffectLight( nvsg::CgFxEffect * effect
00415                                                          , nvsg::CgFxParameter lightParam
00416                                                          , const nvsg::PointLight * pointLight
00417                                                          , const nvmath::Mat44f& modelToWorld
00418                                                          );
00419
00421
00423       NVSG_API virtual void assignSpotLightToEffectLight( nvsg::CgFxEffect * effect
00424                                                         , nvsg::CgFxParameter lightParam
00425                                                         , const nvsg::SpotLight * spotLight
00426                                                         , const nvmath::Mat44f& modelToWorld
00427                                                         );
00428
00430       NVSG_API virtual void overlayBegin( void );
00431
00433       NVSG_API virtual void overlayEnd( void );
00434
00436       NVSG_API virtual void transparentBegin( void );
00437
00439       NVSG_API virtual void transparentEnd( void );
00440
00442       NVSG_API virtual void highlightBegin( void );
00443
00445       NVSG_API virtual void highlightEnd( void );
00446
00448       NVSG_API virtual void primitiveSetsBegin();
00449
00451
00453       NVSG_API virtual bool primitiveSetsEnd();
00454
00455     private:
00456
00457
00458       // A little helper class for screen door transparency.
00459       class StipplePatterns
00460       {
00461         public:
00462           StipplePatterns();
00463           unsigned char  * getBits(int index);
00464
00465         private:
00466           unsigned char  patBytes[ 64 ][ 8 ];
00467           unsigned long stippleBits[64][32];
00468
00469           StipplePatterns( const StipplePatterns &stipplePatterns );
00470           StipplePatterns& operator=( const StipplePatterns &stipplePatterns );
00471       };
00472
00473
00474     private:
00475       void                  doApplyShadowExit( void );
00476       void                  doApplyShadowInit( const nvsg::Scene *scene );
00477       void                  drawMeshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p, GLenum mode, size_t numberOfMeshes, const nvsg::IndexMesh *meshes );
00478       void                  drawMeshedPrimitiveSetDL( const nvsg::MeshedPrimitiveSet *p, GLenum mode, size_t numberOfMeshes, const nvsg::IndexMesh *meshes );
00479       void                  drawMeshedPrimitiveSetVBO( const nvsg::MeshedPrimitiveSet *p, GLenum mode, size_t numberOfMeshes, const nvsg::IndexMesh *meshes );
00480       void                  drawIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, GLenum mode, GLsizei count, const GLvoid *indices );
00481       void                  drawIndependentPrimitiveSetDL( const nvsg::IndependentPrimitiveSet *p, GLenum mode, GLsizei count, const GLvoid *indices );
00482       void                  drawIndependentPrimitiveSetVBO( const nvsg::IndependentPrimitiveSet *p, GLenum mode, GLsizei count, const GLvoid *indices );
00483       void                  drawStrippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p, GLenum mode, size_t numberOfStrips, const nvsg::IndexSet *strips );
00484       void                  drawStrippedPrimitiveSetDL( const nvsg::StrippedPrimitiveSet *p, GLenum mode, size_t numberOfStrips, const nvsg::IndexSet *strips );
00485       void                  drawStrippedPrimitiveSetVBO( const nvsg::StrippedPrimitiveSet *p, GLenum mode, size_t numberOfStrips, const nvsg::IndexSet *strips );
00486       void                  evaluateColorMaterial(const nvsg::PrimitiveSet *p);
00487       nvgl::GLDisplayListCache * getDisplayListCache( const nvsg::PrimitiveSet *p ) const;
00488       nvgl::GLElementArrayBufferCache * getElementArrayBufferCache(const nvsg::PrimitiveSet * p) const;
00489       nvgl::GLArrayBufferCache * getArrayBufferCache( const nvsg::VertexAttributeSet * p ) const;
00490       nvgl::GLTextureCache * getTextureCache(const nvsg::TextureImage * p) const;
00491       void                  handleIndependentPrimitiveSetVBO( const nvsg::IndependentPrimitiveSet * p );
00492       void                  handleMeshedPrimitiveSetVBO( const nvsg::MeshedPrimitiveSet * p );
00493       void                  handleStrippedPrimitiveSetVBO( const nvsg::StrippedPrimitiveSet * p );
00494       void                  indexMeshesToIndexSets( size_t numberOfMeshes, const nvsg::IndexMesh * meshes, std::vector<nvsg::IndexSet> &sets );
00495       static bool           isDisplayListCacheValid( const nvgl::GLDisplayListCache* info );
00496       static bool           isArrayBufferCacheValid( const nvgl::GLArrayBufferCache *info);
00497       static bool           isElementArrayBufferCacheValid( const nvgl::GLElementArrayBufferCache *info);
00498       static bool           isTextureCacheValid( const nvgl::GLTextureCache *info);
00499       void                  jitterClear( void );
00500       void                  jitterInit( void );
00501       void                  prepareEffect( nvsg::CgFxEffect * effect );
00502       void                  processPrimitiveSet( const nvsg::PrimitiveSet *p );
00503       void                  processPrimitiveSetVBO( const nvsg::PrimitiveSet *p, const nvgl::GLElementArrayBufferCache * vboInfoI, const nvgl::GLArrayBufferCache * vboInfoV );
00504       void                  renderCamera( const nvsg::Camera *p );
00505       void                  renderIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, GLenum mode );
00506       void                  renderMeshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p, GLenum mode );
00507       void                  renderStrippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p, GLenum mode );
00508       void                  renderJitteredAccum( const nvsg::ViewState *p );
00509       void                  renderJitteredPBuffer( const nvsg::ViewState *p );
00510       void                  renderJitteredReadPixels( const nvsg::ViewState *p );
00511       bool                  renderLightSource( const nvsg::LightSource *p, bool enable, GLenum &lightId );
00512       void                  renderMono( const nvsg::ViewState *viewState );
00513       void                  renderShadow( const nvsg::Camera *p );
00514       void                  renderStereo( const nvsg::ViewState *viewState );
00515       void                  renderTransparent( const nvsg::Camera *p );
00516       void                  renderTransparentBlended( const nvsg::Camera *p );
00517       void                  renderTransparentOrderIndependent( const nvsg::Camera *p );
00518       void                  setPolygonMode( GLenum face, nvsg::FaceMode mode, const nvsg::FaceAttribute *p = NULL );
00519       void                  shadowClear( void );
00520       void                  tranparencyOITAllocPBuffers( void );
00521       void                  tranparencyOITAllocTextures( void );
00522       void                  transparencyClear( void );
00523       void                  transparencyInit( void );
00524       void                  tranparencyOITFreePBuffers( void );
00525       void                  tranparencyOITFreeTextures( void );
00526       void                  tranparencyOITSetupRendering( void );
00527       bool                  uploadTextureImage( nvsg::TextureImage * texImg, nvgl::GLTextureCache * cache );
00528       bool                  uploadTextureImage1D( nvsg::TextureImage * texImg, nvgl::GLTextureCache * cache );
00529       bool                  uploadTextureImage2D( nvsg::TextureImage * texImg, nvgl::GLTextureCache * cache );
00530       bool                  uploadTextureImage3D( nvsg::TextureImage * texImg, nvgl::GLTextureCache * cache );
00531       bool                  uploadTextureImageCube( nvsg::TextureImage * texImg, nvgl::GLTextureCache * cache );
00532
00533       void genVBOVertices( nvgl::GLArrayBufferCache * viv, const nvsg::VertexAttributeSet * p );
00534       GLsizeiptr getVBOIndexOffset( const nvsg::VertexAttributeSet * p);
00535       void genVBO_VtxBuf_Generic(nvgl::GLArrayBufferCache* vi, const nvsg::VertexAttributeSet * p);
00536       void genVBO_VtxBuf_V3F_N3F(nvgl::GLArrayBufferCache* vi, const nvsg::VertexAttributeSet * p);
00537       void genVBO_VtxBuf_V3F_N3F_T2F(nvgl::GLArrayBufferCache* vi, const nvsg::VertexAttributeSet * p);
00538       void genVBO_VtxBuf_V3F_N3F_T2F_TG3F_BN3F(nvgl::GLArrayBufferCache* vi, const nvsg::VertexAttributeSet * p);
00539       void genVBO_IdxBuf(nvgl::GLElementArrayBufferCache* vi, GLsizeiptr offs, size_t count, const unsigned int * indices);
00540       void genVBO_IdxBuf(nvgl::GLElementArrayBufferCache* vi, GLsizeiptr offs, size_t count, const nvsg::IndexSet * strips);
00541
00542     private:
00543 #if !defined(NDEBUG) && defined(_WIN32)
00544       HGLRC                           m_hglrc;
00545 #endif
00546       bool                                      m_blendAttributeEnabled;
00547       nvmath::Mat44f                            m_clipToView;
00548       size_t                                    m_currentTextureCount;
00549       bool                                      m_halfFloatSupport;
00550       bool                                      m_hiddenObject;
00551       bool                                      m_inShadowMapCreation;
00552       GLuint                                    m_jitterDataSize;                     // for read-pixels-based jittering
00553       GLubyte                                 * m_jitterImageData;
00554       GLushort                                * m_jitterAccumData;
00555       bool                                      m_jitterAccumulationInitialized;      // for pbuffer-based jittering
00556       GLuint                                    m_jitterFPAccumulate;
00557       GLuint                                    m_jitterFPLoad;
00558       GLuint                                    m_jitterFPReturn;
00559       nvgl::PBuffer                           * m_jitterFBuffer[2];
00560       nvgl::PBuffer                           * m_jitterPBuffer;
00561       size_t                                    m_lightCount;
00562       const nvsg::LightSource                 * m_lights[8];
00563       GLint                                     m_maxClipPlanes;
00564       GLint                                     m_maxTextureSize;
00565       GLint                                     m_maxTextureUnits;
00566       nvmath::Mat44f                            m_modelToWorld;
00567       bool                                      m_occlusionQuerySupport;
00568       bool                                      m_primitiveRestartSupport;
00569       nvmath::Vec3f                             m_shadowBackColor;
00570       std::vector<const nvsg::Camera *>         m_shadowLightCameras;
00571       std::vector<const nvsg::LightSource *>    m_shadowLights;
00572       bool                                      m_shadowMapSupport;
00573       size_t                                    m_shadowPass;
00574       std::vector<nvgl::PBuffer*>               m_shadowPBuffers;
00575       std::vector<const nvsg::LightSource *>    m_shadowReplacementLights;
00576       StipplePatterns                           m_stipple;  // for screen door transparency
00577       std::vector<nvsg::IndexSet>               m_tempIndexSets;
00578       bool                                      m_textureNonPowerOfTwoSupport;
00579       GLint                                     m_transparencyOITDepthFormat;
00580       GLuint                                    m_transparencyOITDepthTexture;
00581       GLuint                                    m_transparencyOITFragmentProgram[2];
00582       bool                                      m_transparencyOITInitialized;
00583       std::vector<GLuint>                     * m_transparencyOITOcclusionQueries;
00584       std::vector<GLuint>                       m_transparencyOITPBufferQueries;
00585       std::vector<nvgl::PBuffer*>               m_transparencyOITPBuffers;
00586       std::vector<GLuint>                       m_transparencyOITRGBATextureQueries;
00587       std::vector<GLuint>                       m_transparencyOITRGBATextures;
00588       bool                                      m_transparencyOITRendering;
00589       bool                                      m_transparencyOITSetupPending;
00590       bool                                      m_transparencyOITTransparentPass;
00591       int                                       m_transparencyOITViewportHeight;
00592       int                                       m_transparencyOITViewportWidth;
00593       int                                       m_viewportWidth;
00594       int                                       m_viewportHeight;
00595       nvmath::Mat44f                            m_worldToModel;
00596       nvmath::Mat44f                            m_worldToView;
00597       nvmath::Mat44f                            m_viewToClip;
00598       nvmath::Mat44f                            m_viewToWorld;
00599       bool                                      m_localViewer;
00600       bool                                      m_separateSpecularColor;
00601       bool                                      m_colorMaterial;
00602       const nvsg::Material *                    m_currentMaterial;
00603       const nvsg::Material *                    m_defaultMaterial;
00604       nvsg::CgFxEffect *                        m_currentCgFxEffect;
00605       nvsg::CgFxTechnique                       m_currentCgFxTechnique;
00606       size_t                                    m_currentCgFxNumPasses;
00607       size_t                                    m_currentCgFxPass;
00608
00609       // incarnation maps
00610       std::map<const nvsg::TextureAttributeItem*, nvutil::Incarnation> m_perTexItemIncarnationMap;
00611   };
00612
00613   inline  unsigned char *  GLTraverser::StipplePatterns::getBits( int index )
00614   {
00615     return( (unsigned char *) &stippleBits[ index ][ 0 ] );
00616   }
00617
00618   inline void GLTraverser::setLocalViewer( bool onOff )
00619   {
00620     m_localViewer = onOff;
00621   }
00622
00623   inline bool GLTraverser::isLocalViewerEnabled() const
00624   {
00625     return m_localViewer;
00626   }
00627
00628   inline void GLTraverser::setSeparateSpecularColor( bool onOff )
00629   {
00630     m_separateSpecularColor = onOff;
00631   }
00632
00633   inline bool GLTraverser::isSeparateSpecularColorEnabled( void ) const
00634   {
00635     return m_separateSpecularColor;
00636   }
00637 }
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:33:50 2006 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( size_t x, size_t 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
00167     protected:
00168       HGLRC     m_hglrc;
00169       HDC       m_hdc;
00170
00177       NVSG_API virtual bool initGL( void );
00178
00196       NVSG_API int determinePixelFormat( void );
00197
00198   private:
00199       HWND      m_hWindow;      // Our Window handle
00200 };
00201
00202 }
00203
00204 #endif //_WIN32
Generated on Fri Aug 4 08:33:03 2006 for NVSGSDK by NVIDIA


Group.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Plane3f.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 Fri Aug 4 08:33:51 2006 for NVSGSDK by NVIDIA


Group.h Source File

Group.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/Plane3f.h"
00017 #include "nvsg/Node.h"
00018
00019 namespace nvsg
00020 {
00027 class Group : public Node
00028 {
00029 public:
00035   NVSG_API static const Group * create();
00036
00047   NVSG_API static const Group * createFromBase(const Node &rhs);
00048
00055   NVSG_API virtual const Group * clone() const;
00056
00062   NVSG_API size_t getNumberOfChildren() const;
00063
00089   NVSG_API size_t addChild(const Node * child, size_t position = 0xFFFFFFFF);
00090
00115   NVSG_API const Node * getChild(size_t position) const;
00116
00135   NVSG_API bool removeChild(const Node * child);
00136
00154   NVSG_API void removeChild(size_t position);
00155
00172   NVSG_API bool replaceChild(const Node * newChild, const Node * oldChild);
00173
00189   NVSG_API void replaceChild(const Node * newChild, size_t position);
00190
00199   NVSG_API bool hasChild(const Node * node) const;
00200
00212   NVSG_API bool getChildPositions(const Node * node, std::vector<size_t> & positions) const;
00213
00229   NVSG_API virtual bool containsCgFx() const;
00230
00239   NVSG_API virtual void invalidateCgFxContainment();
00240
00242
00259   NVSG_API virtual bool containsLight() const;
00260
00269   NVSG_API virtual void invalidateLightContainment();
00270
00287   NVSG_API virtual size_t getNumberOfFrames() const;
00288
00297   NVSG_API virtual void invalidateNumberOfFrames() const;
00298
00302   NVSG_API size_t getNumberOfClipPlanes() const;
00303
00307   NVSG_API size_t getNumberOfActiveClipPlanes() const;
00308
00315   NVSG_API bool isClipPlaneActive( size_t index ) const;
00316
00323   NVSG_API const nvmath::Plane3f & getClipPlane( size_t index ) const;
00324
00330   NVSG_API void addClipPlane( const nvmath::Plane3f &plane, bool active = true );
00331
00337   NVSG_API void activateClipPlane( size_t index );
00338
00344   NVSG_API void deactivateClipPlane( size_t index );
00345
00352   NVSG_API void setClipPlane( size_t index, const nvmath::Plane3f &plane );
00353
00370   NVSG_API virtual bool isEquivalent(const Object * object, bool ignoreNames, bool deepCompare) const;
00371
00382   NVSG_API Group & operator=(const Group & rhs);
00383
00384 protected:
00385
00391   NVSG_API Group();
00392
00400   NVSG_API explicit Group( const Node &rhs );
00401
00408   NVSG_API Group( const Group& rhs );
00409
00415   NVSG_API virtual ~Group();
00416
00429   NVSG_API virtual void preRemoveChild(size_t position);
00430
00444   NVSG_API virtual void postRemoveChild(size_t position);
00445
00459   NVSG_API virtual void preAddChild(size_t position);
00460
00473   NVSG_API virtual void postAddChild(size_t position);
00474
00487   NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00488
00496   NVSG_API virtual unsigned short determineHintsContainment( unsigned short hints ) const;
00497
00516   NVSG_API virtual bool determineTransparencyContainment() const;
00517
00533   NVSG_API void invalidateCaches(const Node *child, bool insert);
00534
00541   NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00542
00543 private:
00544   void _deepCopyChildren(const std::vector<const Node*> & children);
00545
00546 private:
00547   std::vector<const Node*>                      m_children;
00548   std::vector<std::pair<bool,nvmath::Plane3f> > m_clipPlanes;
00549
00550   //  State caches
00551   mutable bool    m_containsCgFx;
00552   mutable bool    m_containsCgFxValid;
00553   mutable bool    m_containsLight;
00554   mutable bool    m_containsLightValid;
00555   mutable size_t  m_numberOfFrames;
00556   mutable bool    m_numberOfFramesValid;
00557 };
00558
00559 inline size_t Group::getNumberOfChildren() const
00560 {
00561   NVSG_TRACE();
00562   return( m_children.size() );
00563 }
00564
00565 inline const Node * Group::getChild( size_t position ) const
00566 {
00567   NVSG_TRACE();
00568   NVSG_ASSERT(position<m_children.size()); // undefined behavior for invalid position
00569   return m_children[position];
00570 }
00571
00572 inline size_t Group::getNumberOfClipPlanes() const
00573 {
00574   NVSG_TRACE();
00575   return( m_clipPlanes.size() );
00576 }
00577
00578 inline bool Group::isClipPlaneActive( size_t index ) const
00579 {
00580   NVSG_TRACE();
00581   NVSG_ASSERT( index < m_clipPlanes.size() );
00582   return( m_clipPlanes[index].first );
00583 }
00584
00585 inline const nvmath::Plane3f & Group::getClipPlane( size_t index ) const
00586 {
00587   NVSG_TRACE();
00588   NVSG_ASSERT( index < m_clipPlanes.size() );
00589   return( m_clipPlanes[index].second );
00590 }
00591
00592 inline void Group::addClipPlane( const nvmath::Plane3f &plane, bool active )
00593 {
00594   NVSG_TRACE();
00595   m_clipPlanes.push_back( std::make_pair( active, plane ) );
00596   increaseIncarnation();
00597 }
00598
00599 inline void Group::activateClipPlane( size_t index )
00600 {
00601   NVSG_TRACE();
00602   NVSG_ASSERT( index < m_clipPlanes.size() );
00603   m_clipPlanes[index].first = true;
00604   increaseIncarnation();
00605 }
00606
00607 inline void Group::deactivateClipPlane( size_t index )
00608 {
00609   NVSG_TRACE();
00610   NVSG_ASSERT( index < m_clipPlanes.size() );
00611   m_clipPlanes[index].first = false;
00612   increaseIncarnation();
00613 }
00614
00615 inline void Group::setClipPlane( size_t index, const nvmath::Plane3f &plane )
00616 {
00617   NVSG_TRACE();
00618   NVSG_ASSERT( index < m_clipPlanes.size() );
00619   m_clipPlanes[index].second = plane;
00620   increaseIncarnation();
00621 }
00622
00623 } //  namespace nvsg
Generated on Fri Aug 4 08:33:03 2006 for NVSGSDK by NVIDIA


GroupEliminateTraverser.h File Reference

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

Include dependency graph for GroupEliminateTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Fri Aug 4 08:33:52 2006 for NVSGSDK by NVIDIA


GroupEliminateTraverser.h Source File

GroupEliminateTraverser.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 "nvtraverser/OptimizeTraverser.h"
00018
00019 namespace nvtraverser
00020 {
00022
00026   class GroupEliminateTraverser : public OptimizeTraverser
00027   {
00028     public:
00030       NVSG_API GroupEliminateTraverser( void );
00031
00032     protected:
00034       NVSG_API virtual ~GroupEliminateTraverser( void );
00035
00037       NVSG_API virtual void  doApply( const nvsg::Scene * scene
00038                                     );
00039
00041
00042       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00043                                                    );
00044
00046       NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00047                                            );
00048
00050       NVSG_API virtual void handleGroup( const nvsg::Group * p
00051                                        );
00052
00054       NVSG_API virtual void handleLOD( const nvsg::LOD *p
00055                                      );
00056
00058       NVSG_API virtual void handleSwitch( const nvsg::Switch *p
00059                                         );
00060
00062       NVSG_API virtual void handleTransform( const nvsg::Transform *p
00063                                            );
00064
00065     private:
00066       void eliminateGroups( const nvsg::Group *p );
00067       void eliminateOneChildGroups( const nvsg::Group *p );
00068       bool isGroupCandidate( const nvsg::Group * p );
00069       bool isOneChildGroupCandidate( const nvsg::Group * p );
00070 };
00071 }
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:33:53 2006 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"
00017
00018 namespace nvsg
00019 {
00024   class HighlightBox : public HighlightObject
00025   {
00026     public:
00031       NVSG_API static const HighlightBox * create();
00032
00040       NVSG_API static const HighlightBox * createFromBase( const HighlightObject &rhs );
00041
00045       NVSG_API virtual const HighlightBox * clone() const;
00046
00051       NVSG_API virtual void validate( const Drawable * drawable );
00052
00055       NVSG_API const nvmath::Vec3f* getVertices() const;
00056
00060       NVSG_API const nvmath::Vec3f & getColor() const;
00061
00065       NVSG_API void setColor( const nvmath::Vec3f &color );
00066
00070       NVSG_API float getLineWidth() const;
00071
00075       NVSG_API void setLineWidth( float width );
00076
00082       NVSG_API HighlightBox & operator=(const HighlightBox & rhs);
00083
00084     protected:
00087       NVSG_API HighlightBox();
00088
00095      NVSG_API explicit HighlightBox( const HighlightObject &rhs );
00096
00100       NVSG_API HighlightBox( const HighlightBox &rhs );
00101
00106       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00107
00108     private:
00109       nvmath::Vec3f m_vertices[8];
00110       float         m_lineWidth;
00111       nvmath::Vec3f m_color;
00112   };
00113
00114   inline nvmath::Sphere3f HighlightBox::calculateBoundingSphere() const
00115   {
00116     NVSG_TRACE();
00117     return( boundingSphere( &m_vertices[0], 8 ) );
00118   }
00119
00120   inline const nvmath::Vec3f & HighlightBox::getColor() const
00121   {
00122     NVSG_TRACE();
00123     return( m_color );
00124   }
00125
00126   inline float HighlightBox::getLineWidth() const
00127   {
00128     NVSG_TRACE();
00129     return( m_lineWidth );
00130   }
00131
00132   inline const nvmath::Vec3f* HighlightBox::getVertices() const
00133   {
00134     NVSG_TRACE();
00135     return( m_vertices );
00136   }
00137
00138   inline void HighlightBox::setColor( const nvmath::Vec3f &color )
00139   {
00140     NVSG_TRACE();
00141     m_color = color;
00142   }
00143
00144   inline void HighlightBox::setLineWidth( float width )
00145   {
00146     NVSG_TRACE();
00147     m_lineWidth = width;
00148   }
00149
00150 }
Generated on Fri Aug 4 08:33:03 2006 for NVSGSDK by NVIDIA


HighlightEdges.h File Reference

#include "nvsgcommon.h"
#include "nvsg/HighlightObject.h"
#include "nvsg/PrimitiveSet.h"
#include "nvmath/Sphere3f.h"
#include "nvmath/Vec3f.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 Fri Aug 4 08:33:54 2006 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 #include "nvmath/Sphere3f.h"
00019 #include "nvmath/Vec3f.h"
00020
00021 namespace nvsg
00022 {
00027   class HighlightEdges : public HighlightObject
00028   {
00029     public:
00035       NVSG_API static const HighlightEdges * create( const PrimitiveSet * p );
00036
00045       NVSG_API static const HighlightEdges * createFromBase( const HighlightObject &rhs
00046                                                            , const PrimitiveSet * p );
00047
00051       NVSG_API virtual const HighlightEdges * clone() const;
00052
00056       NVSG_API const nvmath::Vec3f & getColor() const;
00057
00061       NVSG_API void setColor( const nvmath::Vec3f &color );
00062
00066       NVSG_API float getLineWidth() const;
00067
00071       NVSG_API void setLineWidth( float width );
00072
00078       NVSG_API const PrimitiveSet * getPrimitiveSet() const;
00079
00085       NVSG_API HighlightEdges & operator=(const HighlightEdges & rhs);
00086
00087     protected:
00093       NVSG_API HighlightEdges( const PrimitiveSet * p );
00094
00102       NVSG_API HighlightEdges( const HighlightObject &rhs, const PrimitiveSet * p );
00103
00108       NVSG_API HighlightEdges( const HighlightEdges &rhs );
00109
00114       NVSG_API virtual ~HighlightEdges();
00115
00120       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00121
00122     private:
00123       HighlightEdges();   //  private default constructor to prevent usage
00124
00125       void preparePrimitiveSet();
00126
00127     private :
00128       const PrimitiveSet *  m_primitiveSet;
00129       float                 m_lineWidth;
00130       nvmath::Vec3f         m_color;
00131   };
00132
00133   inline nvmath::Sphere3f HighlightEdges::calculateBoundingSphere() const
00134   {
00135     NVSG_TRACE();
00136     NVSG_ASSERT( m_primitiveSet );
00137     return( m_primitiveSet->getBoundingSphere() );
00138   }
00139
00140   inline const nvmath::Vec3f & HighlightEdges::getColor() const
00141   {
00142     NVSG_TRACE();
00143     return( m_color );
00144   }
00145
00146   inline float HighlightEdges::getLineWidth() const
00147   {
00148     NVSG_TRACE();
00149     return( m_lineWidth );
00150   }
00151
00152   inline void HighlightEdges::setColor( const nvmath::Vec3f &color )
00153   {
00154     NVSG_TRACE();
00155     m_color = color;
00156   }
00157
00158   inline void HighlightEdges::setLineWidth( float width )
00159   {
00160     NVSG_TRACE();
00161     m_lineWidth = width;
00162   }
00163
00164   inline const PrimitiveSet * HighlightEdges::getPrimitiveSet() const
00165   {
00166     NVSG_TRACE();
00167     return( m_primitiveSet );
00168   }
00169 }
Generated on Fri Aug 4 08:33:03 2006 for NVSGSDK by NVIDIA


HighlightObject.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.h"
#include "nvmath/Sphere3f.h"
#include "nvutil/Lockable.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 Fri Aug 4 08:33:55 2006 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 "nvsg/Object.h"
00017 #include "nvmath/Sphere3f.h"
00018 #include "nvutil/Lockable.h"
00019
00020 namespace nvsg
00021 {
00022   class Drawable;
00023
00028   class HighlightObject : public Object
00029   {
00030     public:
00036       NVSG_API const nvmath::Sphere3f & getBoundingSphere() const;
00037
00041       NVSG_API void invalidateBoundingSphere();
00042
00046       NVSG_API void invalidate();
00047
00053       NVSG_API bool isValid() const;
00054
00059       NVSG_API virtual void validate( const Drawable * drawable );
00060
00061     protected:
00066       NVSG_API HighlightObject();
00067
00072       NVSG_API HighlightObject( const HighlightObject &rhs );
00073
00078       NVSG_API virtual ~HighlightObject();
00079
00084       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const = 0;
00085
00091       NVSG_API HighlightObject & operator=(const HighlightObject & rhs);
00092
00093     private:
00094       mutable nvmath::Sphere3f m_boundingSphere;
00095       mutable bool             m_boundingSphereValid;
00096       bool                     m_valid;
00097   };
00098
00099   inline bool HighlightObject::isValid() const
00100   {
00101     NVSG_TRACE();
00102     return( m_valid );
00103   }
00104
00105   inline void HighlightObject::invalidate()
00106   {
00107     NVSG_TRACE();
00108     m_valid = false;
00109   }
00110 }
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:33:56 2006 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
00017 #include "nvsgcommon.h"
00018
00019 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvtraverser
00022 {
00024   class IdentityToGroupTraverser : public OptimizeTraverser
00025   {
00026     public:
00028       NVSG_API IdentityToGroupTraverser( void );
00029
00030     protected:
00032       NVSG_API virtual ~IdentityToGroupTraverser( void );
00033
00035       NVSG_API virtual void doApply( const nvsg::Scene  * scene
00036                                    );
00037
00039
00040       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform * p
00041                                                    );
00042
00044       NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00045                                            );
00046
00048       NVSG_API virtual void handleGroup( const nvsg::Group *p
00049                                        );
00050
00052       NVSG_API virtual void handleLOD( const nvsg::LOD *p
00053                                      );
00054
00056       NVSG_API virtual void handleSwitch( const nvsg::Switch *p
00057                                         );
00058
00060       NVSG_API virtual void handleTransform( const nvsg::Transform *p
00061                                            );
00062
00063     private:
00064       const nvsg::Group * createGroupFromTransform( const nvsg::Transform *pTransform );
00065       void                replaceTransforms( const nvsg::Group *p );
00066   };
00067 }
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:33:58 2006 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:
00034       NVSG_API virtual bool isDataShared() const;
00035
00039       NVSG_API virtual DataID getDataID() const;
00040
00044       NVSG_API bool hasIndices() const;
00045
00049       NVSG_API size_t getNumberOfIndices() const;
00050
00054       NVSG_API const unsigned int * getIndices() const;
00055
00063       NVSG_API void setIndices( const unsigned int * indices
00064                               , size_t numIndices );
00065
00082       NVSG_API void setIndices( size_t pos
00083                               , const unsigned int * indices
00084                               , size_t numIndices );
00085
00099       NVSG_API virtual bool isEquivalent( const Object *p
00100                                         , bool ignoreNames
00101                                         , bool deepCompare ) const;
00102
00106       NVSG_API virtual const IndependentPrimitiveSet * clone() const = 0;
00107
00108     protected:
00113       NVSG_API IndependentPrimitiveSet();
00114
00122       NVSG_API explicit IndependentPrimitiveSet( const PrimitiveSet &rhs );
00123
00129       NVSG_API IndependentPrimitiveSet( const IndependentPrimitiveSet& rhs );
00130
00135       NVSG_API virtual ~IndependentPrimitiveSet();
00136
00141       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00142
00148       NVSG_API IndependentPrimitiveSet & operator=(const IndependentPrimitiveSet & rhs);
00149
00150     private:
00151       nvutil::RCPtr<nvutil::RCVector<unsigned int> > m_indices;
00152   };
00153
00154
00155   // - - - - - - - - - - - - - - - - - - - - - - - - -
00156   // inlines
00157   // - - - - - - - - - - - - - - - - - - - - - - - - -
00158
00159   inline bool IndependentPrimitiveSet::hasIndices()  const
00160   {
00161     return( !m_indices->empty() );
00162   }
00163
00164   inline size_t IndependentPrimitiveSet::getNumberOfIndices()  const
00165   {
00166     return( m_indices->size() );
00167   }
00168
00169   inline const unsigned int * IndependentPrimitiveSet::getIndices() const
00170   {
00171     NVSG_TRACE();
00172     return( &(*m_indices)[0] );
00173   }
00174 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


InterpolatedAnimation.h File Reference

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

Include dependency graph for InterpolatedAnimation.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 Fri Aug 4 08:33:59 2006 for NVSGSDK by NVIDIA


InterpolatedAnimation.h Source File

InterpolatedAnimation.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/Animation.h"
00018
00019 namespace nvsg
00020 {
00029   template<typename T> class InterpolatedAnimation : public Animation<T>
00030   {
00031     public:
00036       virtual size_t getNumberOfFrames( void ) const;
00037
00043       size_t getNumberOfKeys( void ) const;
00044
00050       void setNumberOfKeys( size_t count );
00051
00059       void setKeyFrame( size_t key
00060                       , unsigned int frame
00061                       , const T & value );
00062
00069       unsigned int getFrame( size_t key ) const;
00070
00077       const T & getValue( size_t key ) const;
00078
00092       virtual bool isEquivalent( const Object * p
00093                                , bool ignoreNames
00094                                , bool deepCompare ) const;
00095
00096     protected:
00101       InterpolatedAnimation( void );
00102
00107       InterpolatedAnimation( const InterpolatedAnimation &rhs );
00108
00113       virtual ~InterpolatedAnimation( void );
00114
00119       unsigned int getCurrentFrame( void ) const;
00120
00125       const T & getCurrentValue( void ) const;
00126
00134       size_t getKey( unsigned int frame ) const;
00135
00142       void  setCurrent( size_t key ) const;
00143
00148       void  setCurrent( unsigned int frame, const T &value ) const;
00149
00156       InterpolatedAnimation<T> & operator=(const InterpolatedAnimation<T> & rhs);
00157
00158     private:
00159       std::vector<unsigned int>  m_keys;
00160       std::vector<T>             m_values;
00161       mutable unsigned int  m_currentFrame;
00162       mutable T             m_currentValue;
00163   };
00164
00165   template<typename T>
00166   inline InterpolatedAnimation<T>::InterpolatedAnimation( void )
00167   : Animation<T>()
00168   , m_currentFrame(0xFFFFFFFF)
00169   {
00170     NVSG_TRACE();
00171   }
00172
00173   template<typename T>
00174   inline InterpolatedAnimation<T>::InterpolatedAnimation( const InterpolatedAnimation &rhs )
00175   : Animation<T>(rhs)
00176   , m_keys( rhs.m_keys )
00177   , m_values( rhs.m_values )
00178   , m_currentFrame( rhs.m_currentFrame )
00179   , m_currentValue( rhs.m_currentValue )
00180   {
00181     NVSG_TRACE();
00182   }
00183
00184   template<typename T>
00185   inline InterpolatedAnimation<T>::~InterpolatedAnimation(void)
00186   {
00187     NVSG_TRACE();
00188   }
00189
00190   template<typename T>
00191   inline size_t InterpolatedAnimation<T>::getNumberOfFrames( void ) const
00192   {
00193     NVSG_TRACE();
00194     NVSG_ASSERT( m_keys.size() );                    //  the last key holds the index of the last frame,
00195     return( 1 + m_keys[m_keys.size()-1] );      //  but the number of frames is one greater
00196   }
00197
00198   template<typename T>
00199   inline size_t InterpolatedAnimation<T>::getNumberOfKeys( void ) const
00200   {
00201     NVSG_TRACE();
00202     return( m_keys.size() );
00203   }
00204
00205   template<typename T>
00206   inline void InterpolatedAnimation<T>::setNumberOfKeys( size_t count )
00207   {
00208     NVSG_TRACE();
00209     m_keys.resize( count );
00210     m_values.resize( count );
00211     increaseIncarnation();
00212   }
00213
00214   template<typename T>
00215   inline void InterpolatedAnimation<T>::setKeyFrame( size_t key, unsigned int frame, const T &value )
00216   {
00217     NVSG_TRACE();
00218     NVSG_ASSERT( key < m_keys.size() );
00219     m_keys[key]   = frame;
00220     m_values[key] = value;
00221     increaseIncarnation();
00222   }
00223
00224   template<typename T>
00225   inline unsigned int InterpolatedAnimation<T>::getCurrentFrame( void ) const
00226   {
00227     NVSG_TRACE();
00228     return( m_currentFrame );
00229   }
00230
00231   template<typename T>
00232   inline const T & InterpolatedAnimation<T>::getCurrentValue( void ) const
00233   {
00234     NVSG_TRACE();
00235     return( m_currentValue );
00236   }
00237
00238   template<typename T>
00239   inline unsigned int InterpolatedAnimation<T>::getFrame( size_t key ) const
00240   {
00241     NVSG_TRACE();
00242     NVSG_ASSERT( key < m_keys.size() );
00243     return( m_keys[key] );
00244   }
00245
00246   template<typename T>
00247   inline const T & InterpolatedAnimation<T>::getValue( size_t key ) const
00248   {
00249     NVSG_TRACE();
00250     NVSG_ASSERT( key < m_keys.size() );
00251     return( m_values[key] );
00252   }
00253
00254   template<typename T>
00255   inline size_t InterpolatedAnimation<T>::getKey( unsigned int frame ) const
00256   {
00257     NVSG_TRACE();
00258     NVSG_ASSERT( frame < getNumberOfFrames() );
00259     std::vector<unsigned int>::const_iterator it = std::lower_bound( m_keys.begin(), m_keys.end(), frame );
00260     NVSG_ASSERT( it != m_keys.end() );
00261     return( it - m_keys.begin() );
00262   }
00263
00264   template<typename T>
00265   inline void InterpolatedAnimation<T>::setCurrent( size_t key ) const
00266   {
00267     NVSG_TRACE();
00268     NVSG_ASSERT( ( key < m_keys.size() ) && ( m_keys.size() == m_values.size() ) );
00269     m_currentFrame = m_keys[key];
00270     m_currentValue = m_values[key];
00271   }
00272
00273   template<typename T>
00274   inline void InterpolatedAnimation<T>::setCurrent( unsigned int frame, const T &value ) const
00275   {
00276     NVSG_TRACE();
00277     m_currentFrame = frame;
00278     m_currentValue = value;
00279   }
00280
00281
00282   template<typename T>
00283   InterpolatedAnimation<T> & InterpolatedAnimation<T>::operator=(const InterpolatedAnimation<T> & rhs)
00284   {
00285     NVSG_TRACE();
00286     if (&rhs != this)
00287     {
00288       Animation<T>::operator=(rhs);
00289       m_keys          = rhs.m_keys;
00290       m_values        = rhs.m_values;
00291       m_currentFrame  = rhs.m_currentFrame;
00292       m_currentValue  = rhs.m_currentValue;
00293     }
00294     return *this;
00295   }
00296
00297   template<typename T>
00298   inline bool InterpolatedAnimation<T>::isEquivalent( const Object * p, bool ignoreNames, bool deepCompare) const
00299   {
00300     bool equi = Animation<T>::isEquivalent( p, ignoreNames, deepCompare );
00301     if ( equi )
00302     {
00303       const InterpolatedAnimation<T> * iat = dynamic_cast<const InterpolatedAnimation<T>*>(p);
00304       equi = ( m_keys == iat->m_keys ) && ( m_values == iat->m_values );
00305     }
00306     return( equi );
00307   }
00308
00309 }
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:33:59 2006 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 Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


LightSource.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Animation.h"
#include "nvsg/Node.h"
#include "nvmath/Quatf.h"
#include "nvmath/Trafo.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 Fri Aug 4 08:34:01 2006 for NVSGSDK by NVIDIA


LightSource.h Source File

LightSource.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/Animation.h"
00017 #include "nvsg/Node.h"
00018 #include "nvmath/Quatf.h"
00019 #include "nvmath/Trafo.h"
00020
00021 namespace nvsg
00022 {
00049   class LightSource : public Node
00050   {
00051     public:
00058       NVSG_API const nvmath::Vec3f& getAmbientColor() const;
00059
00066       NVSG_API void setAmbientColor( const nvmath::Vec3f &color );
00067
00074       NVSG_API const nvmath::Vec3f& getDiffuseColor() const;
00075
00082       NVSG_API void setDiffuseColor( const nvmath::Vec3f &color );
00083
00090       NVSG_API const nvmath::Vec3f& getSpecularColor() const;
00091
00098       NVSG_API void setSpecularColor( const nvmath::Vec3f &color );
00099
00105       NVSG_API float getIntensity() const;
00106
00112       NVSG_API void setIntensity( float intensity );
00113
00119       NVSG_API bool isShadowCasting() const;
00120
00126       NVSG_API void setShadowCasting( bool cast );
00127
00134       NVSG_API const Animation<nvmath::Trafo> * getAnimation() const;
00135
00141       NVSG_API void setAnimation( const Animation<nvmath::Trafo> * animation );
00142
00150       NVSG_API void setAnimationFrame( size_t frame );
00151
00155       NVSG_API virtual size_t getNumberOfFrames() const;
00156
00160       NVSG_API nvmath::Mat44f getTransformationMatrix() const;
00161
00166       NVSG_API nvmath::Mat44f getInverse() const;
00167
00171       NVSG_API virtual bool containsLight() const;
00172
00176       NVSG_API virtual const LightSource * clone() const = 0;
00177
00191       NVSG_API virtual bool isEquivalent( const Object * p
00192                                         , bool ignoreNames
00193                                         , bool deepCompare ) const;
00194
00195     protected:
00207       NVSG_API LightSource();
00208
00214       NVSG_API LightSource( const LightSource& rhs );
00215
00221       NVSG_API virtual ~LightSource();
00222
00229       NVSG_API LightSource & operator=(const LightSource & rhs);
00230
00236       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00237
00244       NVSG_API virtual bool determineTransparencyContainment() const;
00245
00252       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00253
00254     protected:
00255       nvmath::Trafo m_trafo;
00256
00257     private:
00258       nvmath::Vec3f                     m_ambientColor;
00259       const Animation<nvmath::Trafo>  * m_animation; // animation working on a Trafo
00260       size_t                            m_currentFrame;
00261       nvmath::Vec3f                     m_diffuseColor;
00262       float                             m_intensity;
00263       bool                              m_shadowCasting;
00264       nvmath::Vec3f                     m_specularColor;
00265   };
00266
00267   inline const nvmath::Vec3f& LightSource::getAmbientColor() const
00268   {
00269     NVSG_TRACE();
00270     return( m_ambientColor );
00271   }
00272
00273   inline const Animation<nvmath::Trafo> * LightSource::getAnimation() const
00274   {
00275     NVSG_TRACE();
00276     return( m_animation );
00277   }
00278
00279   inline const nvmath::Vec3f& LightSource::getDiffuseColor() const
00280   {
00281     NVSG_TRACE();
00282     return( m_diffuseColor );
00283   }
00284
00285   inline float LightSource::getIntensity() const
00286   {
00287     NVSG_TRACE();
00288     return( m_intensity );
00289   }
00290
00291   inline nvmath::Mat44f LightSource::getInverse() const
00292   {
00293     NVSG_TRACE();
00294     return m_trafo.getInverse();
00295   }
00296
00297   inline size_t LightSource::getNumberOfFrames() const
00298   {
00299     NVSG_TRACE();
00300     return( m_animation ? m_animation->getNumberOfFrames() : 0 );
00301   }
00302
00303   inline const nvmath::Vec3f& LightSource::getSpecularColor() const
00304   {
00305     NVSG_TRACE();
00306     return( m_specularColor );
00307   }
00308
00309   inline nvmath::Mat44f LightSource::getTransformationMatrix() const
00310   {
00311     NVSG_TRACE();
00312     return m_trafo.getMatrix();
00313   }
00314
00315   inline bool LightSource::isShadowCasting() const
00316   {
00317     NVSG_TRACE();
00318     return( m_shadowCasting );
00319   }
00320
00321   inline void LightSource::setAmbientColor( const nvmath::Vec3f &c )
00322   {
00323     NVSG_TRACE();
00324     m_ambientColor = c;
00325     increaseIncarnation();
00326   }
00327
00328   inline void LightSource::setDiffuseColor( const nvmath::Vec3f &c )
00329   {
00330     NVSG_TRACE();
00331     m_diffuseColor = c;
00332     increaseIncarnation();
00333   }
00334
00335   inline void LightSource::setIntensity( float i )
00336   {
00337     NVSG_TRACE();
00338     m_intensity = i;
00339     increaseIncarnation();
00340   }
00341
00342   inline void LightSource::setSpecularColor( const nvmath::Vec3f &c )
00343   {
00344     NVSG_TRACE();
00345     m_specularColor = c;
00346     increaseIncarnation();
00347   }
00348
00349   inline void LightSource::setShadowCasting( bool cast )
00350   {
00351     NVSG_TRACE();
00352     m_shadowCasting = cast;
00353     increaseIncarnation();
00354   }
00355 } //  namespace nvsg
00356
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


LinearInterpolatedAnimation.h File Reference

#include "nvsgcommon.h"
#include "nvsg/InterpolatedAnimation.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 Fri Aug 4 08:34:02 2006 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/InterpolatedAnimation.h"
00017
00018 #if !defined(DOXYGEN_IGNORE)
00019 # if !defined(NDEBUG)
00020 #  ifndef new
00021 #   define new new(__FILE__, __LINE__)
00022 #   define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
00023 #  endif
00024 # endif
00025 #endif
00026
00027 namespace nvsg
00028 {
00036   template<typename T> class LinearInterpolatedAnimation : public InterpolatedAnimation<T>
00037   {
00038     public:
00041       static const LinearInterpolatedAnimation<T> * create();
00042
00052       static const LinearInterpolatedAnimation<T> * createFromBase( const InterpolatedAnimation<T> &rhs );
00053
00058       virtual const LinearInterpolatedAnimation<T> * clone() const;
00059
00067       NVSG_API virtual const T & operator[]( size_t frame ) const;
00068
00075       LinearInterpolatedAnimation<T> & operator=(const LinearInterpolatedAnimation<T> & rhs);
00076
00077     protected:
00082       NVSG_API LinearInterpolatedAnimation();
00083
00090       NVSG_API explicit LinearInterpolatedAnimation( const InterpolatedAnimation<T> &rhs );
00091
00097       NVSG_API LinearInterpolatedAnimation( const LinearInterpolatedAnimation &rhs );
00098
00103       NVSG_API virtual ~LinearInterpolatedAnimation();
00104   };
00105
00106   template<typename T>
00107     const LinearInterpolatedAnimation<T> * LinearInterpolatedAnimation<T>::create()
00108   {
00109     NVSG_TRACE();
00110     return( new LinearInterpolatedAnimation<T> );
00111   }
00112
00113   template<typename T>
00114     const LinearInterpolatedAnimation<T> * LinearInterpolatedAnimation<T>::createFromBase( const InterpolatedAnimation<T> &rhs )
00115   {
00116     NVSG_TRACE();
00117     return( new LinearInterpolatedAnimation<T>( rhs ) );
00118   }
00119
00120   template<typename T>
00121     const LinearInterpolatedAnimation<T> * LinearInterpolatedAnimation<T>::clone() const
00122   {
00123     NVSG_TRACE();
00124     return( new LinearInterpolatedAnimation<T>( *this ) );
00125   }
00126
00127   template<typename T>
00128     LinearInterpolatedAnimation<T> & LinearInterpolatedAnimation<T>::operator=(const LinearInterpolatedAnimation<T> & rhs)
00129   {
00130     NVSG_TRACE();
00131     return( InterpolatedAnimation<T>::operator=(rhs) );
00132   }
00133
00134 }
00135
00136 #ifdef _DEFINED_DBGNEW
00137 # undef new
00138 #endif
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:34:02 2006 for NVSGSDK by NVIDIA


LineAttribute.h Source File

LineAttribute.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/PrimitiveAttribute.h"
00017 #include <float.h>
00018
00019 namespace nvsg
00020 {
00026   class LineAttribute : public PrimitiveAttribute
00027   {
00028     public:
00036       NVSG_API static const LineAttribute * create();
00037
00045       NVSG_API static const LineAttribute * createFromBase( const PrimitiveAttribute &rhs );
00046
00050       NVSG_API virtual const LineAttribute * clone() const;
00051
00060       NVSG_API unsigned short getStipplePattern() const;
00061
00070       NVSG_API void setStipplePattern( unsigned short pattern );
00071
00079       NVSG_API unsigned short getStippleFactor() const;
00080
00088       NVSG_API void setStippleFactor( unsigned short factor );
00089
00095       NVSG_API float getWidth() const;
00096
00102       NVSG_API void setWidth( float width );
00103
00107       NVSG_API bool isAntiAliased() const;
00108
00112       NVSG_API void setAntiAliasing( bool aa );
00113
00122       NVSG_API virtual bool isEquivalent( const Object * p
00123                                         , bool ignoreNames
00124                                         , bool deepCompare ) const;
00125
00132       NVSG_API LineAttribute & operator=(const LineAttribute & rhs);
00133
00134     protected:
00138       NVSG_API LineAttribute();
00139
00146       NVSG_API explicit LineAttribute( const PrimitiveAttribute &rhs );
00147
00152       NVSG_API LineAttribute( const LineAttribute &rhs );
00153
00158       NVSG_API virtual ~LineAttribute();
00159
00160     private:
00161       bool            m_antiAliasing;
00162       unsigned short  m_stippleFactor;
00163       unsigned short  m_stipplePattern;
00164       float           m_width;
00165   };
00166
00167   inline unsigned short LineAttribute::getStippleFactor() const
00168   {
00169     return( m_stippleFactor );
00170   }
00171
00172   inline unsigned short LineAttribute::getStipplePattern() const
00173   {
00174     return( m_stipplePattern );
00175   }
00176
00177   inline float LineAttribute::getWidth() const
00178   {
00179     return( m_width );
00180   }
00181
00182   inline bool LineAttribute::isAntiAliased() const
00183   {
00184     return( m_antiAliasing );
00185   }
00186
00187   inline void LineAttribute::setAntiAliasing( bool aa )
00188   {
00189     m_antiAliasing = aa;
00190     increaseIncarnation();
00191   }
00192
00193   inline void LineAttribute::setStippleFactor( unsigned short factor )
00194   {
00195     NVSG_ASSERT( ( 0 < factor ) && ( factor < 256 ) );
00196     m_stippleFactor = factor;
00197     increaseIncarnation();
00198   }
00199
00200   inline void LineAttribute::setStipplePattern( unsigned short pattern )
00201   {
00202     m_stipplePattern = pattern;
00203     increaseIncarnation();
00204   }
00205
00206   inline void LineAttribute::setWidth( float width )
00207   {
00208     NVSG_ASSERT( FLT_EPSILON < width );
00209     m_width = width;
00210     increaseIncarnation();
00211   }
00212
00213 } // namespace nvsg
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


Lines.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Face.h"
#include "nvsg/IndependentPrimitiveSet.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 Fri Aug 4 08:34:03 2006 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/Face.h"
00017 #include "nvsg/IndependentPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00027   class Lines : public IndependentPrimitiveSet
00028   {
00029     public:
00033       NVSG_API static const Lines * create();
00034
00042       NVSG_API static const Lines * createFromBase( const IndependentPrimitiveSet &rhs );
00043
00051       NVSG_API static const Lines * createFromBase( const PrimitiveSet &rhs );
00052
00056       NVSG_API virtual const Lines * clone() const;
00057
00062       NVSG_API bool hasSegments() const;
00063
00068       NVSG_API size_t getNumberOfSegments() const;
00069
00074       NVSG_API const Segment * getSegments() const;
00075
00084       NVSG_API void setSegments( const Segment * segments
00085                                , size_t numSegments );
00086
00103       NVSG_API void setSegments( size_t pos
00104                                , const Segment * segments
00105                                , size_t numSegments );
00106
00112       NVSG_API Lines & operator=(const Lines & rhs);
00113
00114     protected:
00117       NVSG_API Lines();
00118
00125       NVSG_API explicit Lines( const IndependentPrimitiveSet &rhs );
00126
00132       NVSG_API explicit Lines( const PrimitiveSet &rhs );
00133
00137       NVSG_API Lines( const Lines &rhs );
00138
00143       NVSG_API virtual ~Lines();
00144   };
00145
00146   // - - - - - - - - - - - - - - - - - - - - - - - - -
00147   // inlines
00148   // - - - - - - - - - - - - - - - - - - - - - - - - -
00149
00150   inline bool Lines::hasSegments()  const
00151   {
00152     NVSG_TRACE();
00153     return( 2 <= getNumberOfIndices() );
00154   }
00155
00156   inline size_t Lines::getNumberOfSegments()  const
00157   {
00158     NVSG_TRACE();
00159     return( getNumberOfIndices() / 2 );
00160   }
00161
00162   inline const Segment * Lines::getSegments() const
00163   {
00164     NVSG_TRACE();
00165     return( (const Segment *) getIndices() );
00166   }
00167
00168   inline void Lines::setSegments( const Segment* pSegments, size_t numSegments )
00169   {
00170     NVSG_TRACE();
00171     setIndices( (const unsigned int *) pSegments, 2 * numSegments );
00172   }
00173
00174   inline void Lines::setSegments( size_t pos, const Segment* pSegments, size_t numSegments )
00175   {
00176     NVSG_TRACE();
00177     if ( (size_t)-1 != pos )
00178     {
00179       pos *= 2;
00180     }
00181     setIndices( pos, (const unsigned int *) pSegments, 2 * numSegments );
00182   }
00183
00184   inline Lines & Lines::operator=(const Lines & rhs)
00185   {
00186     NVSG_TRACE();
00187     IndependentPrimitiveSet::operator=(rhs);
00188     return( *this );
00189   }
00190 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


LineStrips.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/StrippedPrimitiveSet.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 Fri Aug 4 08:34:05 2006 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/nvsg.h"
00017 #include "nvsg/StrippedPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00027   class LineStrips : public StrippedPrimitiveSet
00028   {
00029     public:
00033       NVSG_API static const LineStrips * create();
00034
00042       NVSG_API static const LineStrips * createFromBase( const StrippedPrimitiveSet &rhs );
00043
00047       NVSG_API virtual const LineStrips * clone() const;
00048
00053       NVSG_API LineStrips & operator=( const LineStrips & rhs );
00054
00055     protected:
00058       NVSG_API LineStrips();
00059
00066       NVSG_API explicit LineStrips( const StrippedPrimitiveSet &rhs );
00067
00071       NVSG_API LineStrips( const LineStrips &rhs );
00072
00077       NVSG_API virtual ~LineStrips();
00078   };
00079 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


Lockable.h File Reference

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

Include dependency graph for Lockable.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 Fri Aug 4 08:34:06 2006 for NVSGSDK by NVIDIA


Lockable.h Source File

Lockable.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/SWMRSync.h"
00017
00018 namespace nvutil
00019 {
00021
00056   template<typename T>
00057   class Lockable : public ISWMRSync
00058   {
00059     public:
00061       explicit Lockable(T* ptr):m_ptr(ptr)      {}
00063       explicit Lockable(const Lockable<T>& rhs) { m_ptr = new T(*rhs.m_ptr); }
00065       ~Lockable()                               { deletePointer(); }
00066
00068       T* operator->()                           { return m_ptr; }
00070       const T* operator->() const               { return m_ptr; }
00071
00073       T& operator*()                            { return *m_ptr; }
00075       const T& operator*() const                { return *m_ptr; }
00076
00078       const T* get() const                      { return m_ptr; }
00079
00081
00083       void reset(T * ptr);
00084
00085     private:
00086       T* m_ptr;
00087
00088     private:
00089       Lockable<T>& operator=(const Lockable<T>& rhs); // Assignment not allowed.
00090
00091       void deletePointer(); // Delete the internal object and assign NULL.
00092   };
00093
00094   template <typename T>
00095   inline void Lockable<T>::reset(T * ptr)
00096   {
00097     if ( m_ptr != ptr )
00098     {
00099       deletePointer();
00100
00101       m_ptr = ptr;
00102       // !! don't add reference here !!
00103     }
00104   }
00105
00106   template <typename T>
00107   inline void Lockable<T>::deletePointer()
00108   {
00109     if ( m_ptr )
00110     {
00111       delete m_ptr;
00112       m_ptr = NULL;
00113     }
00114   }
00115
00116   template<typename T>
00117   inline Lockable<T>& beginEdit(const Lockable<T>& ref)
00118   {
00119     ref.waitToWrite();
00120     return const_cast<Lockable<T>& >(ref);
00121   }
00122
00123   template<typename T>
00124   inline const Lockable<T>& endEdit(Lockable<T>& ref)
00125   {
00126     ref.doneWriting();
00127     return( ref );
00128   }
00129 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


LOD.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Mat44f.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 Fri Aug 4 08:34:07 2006 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/Mat44f.h"
00017 #include "nvsg/Group.h"
00018
00019 namespace nvsg
00020 {
00049   class LOD : public Group
00050   {
00051     public:
00056       NVSG_API static const LOD * create();
00057
00065       NVSG_API static const LOD * createFromBase(const Group &rhs);
00066
00070       NVSG_API virtual const LOD * clone() const;
00071
00089       NVSG_API void setRanges(const float * ranges, size_t count);
00090
00098       NVSG_API const float * getRanges() const;
00099
00103       NVSG_API size_t getNumberOfRanges() const;
00104
00113       NVSG_API void setCenter(const nvmath::Vec3f & center);
00114
00119       NVSG_API const nvmath::Vec3f & getCenter() const;
00120
00137       NVSG_API virtual size_t getLODToUse(const nvmath::Mat44f & modelViewMatrix, float scaleFactor) const;
00138
00176       NVSG_API void setRangeLock(bool on, size_t rangeNumber);
00177
00182       NVSG_API size_t getRangeLock() const;
00183
00187       NVSG_API bool isRangeLockEnabled() const;
00188
00195       NVSG_API LOD & operator=(const LOD & rhs);
00196
00205       NVSG_API virtual bool isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const;
00206
00207     protected:
00211       NVSG_API LOD( void );
00212
00219       NVSG_API explicit LOD( const Group &rhs );
00220
00225       NVSG_API LOD( const LOD &rhs );
00226
00231       NVSG_API virtual ~LOD( void );
00232
00233     private:
00234       nvmath::Vec3f        m_center;
00235       std::vector<float>   m_ranges;
00236       size_t               m_rangeLock;
00237       bool                 m_isRangeLocked;
00238   };
00239 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


LODCombineTraverser.h File Reference

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

Include dependency graph for LODCombineTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Fri Aug 4 08:34:08 2006 for NVSGSDK by NVIDIA


LODCombineTraverser.h Source File

LODCombineTraverser.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
00017 #include "nvsgcommon.h"
00018
00019 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvtraverser
00022 {
00024   class LODCombineTraverser : public OptimizeTraverser
00025   {
00026     public:
00028       NVSG_API LODCombineTraverser( void );
00029
00030     protected:
00032       NVSG_API virtual ~LODCombineTraverser( void );
00033
00035
00036       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00037                                                    );
00038
00040       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p
00041                                            );
00042
00044       NVSG_API virtual void handleGroup( const nvsg::Group * p
00045                                        );
00046
00048       NVSG_API virtual void handleTransform( const nvsg::Transform * p
00049                                            );
00050
00051     private:
00052       void combineLODs( const nvsg::Group *p );
00053   };
00054
00055 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


LODEliminateTraverser.h File Reference

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

Include dependency graph for LODEliminateTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Fri Aug 4 08:34:09 2006 for NVSGSDK by NVIDIA


LODEliminateTraverser.h Source File

LODEliminateTraverser.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 "nvtraverser/OptimizeTraverser.h"
00018
00019 namespace nvtraverser
00020 {
00022
00024   class LODEliminateTraverser : public OptimizeTraverser
00025   {
00026     public:
00028       NVSG_API LODEliminateTraverser( void );
00029
00030     protected:
00032       NVSG_API virtual ~LODEliminateTraverser( void );
00033
00035       NVSG_API virtual void  doApply( const nvsg::Scene * scene
00036                                     );
00037
00039
00040       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00041                                                    );
00042
00044       NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00045                                            );
00046
00048       NVSG_API virtual void handleGroup( const nvsg::Group * p
00049                                        );
00050
00052       NVSG_API virtual void handleLOD( const nvsg::LOD *p
00053                                      );
00054
00056       NVSG_API virtual void handleSwitch( const nvsg::Switch *p
00057                                         );
00058
00060       NVSG_API virtual void handleTransform( const nvsg::Transform *p
00061                                            );
00062
00063     private:
00064       void eliminateLODs( const nvsg::Group *p );
00065       bool isLODCandidate( const nvsg::LOD * p );
00066 };
00067 }
Generated on Fri Aug 4 08:33:04 2006 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_BENCH_TEST_INIT(TM) nvutil::LogBenchTest::instance()->init(TM==nvutil::TM_BENCH_TEST)
Initialize benchmark test logging.

#define | NVSG_LOG_SHADER_TEST_INIT(TM) nvutil::LogShaderTest::instance()->init(TM==nvutil::TM_SHADER_TEST)
Ininialize shader 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_BENCH_TEST(s) { if ( nvutil::LogBenchTest::instance()->isEnabled() ) { nvutil::LogBenchTest::instance()->format s; } }
Output benchmark test relevant format string s if output is enabled.

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

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

#define | NVSG_LOG_BENCH_TEST_ENABLED() nvutil::LogBenchTest::instance()->isEnabled()
Query if benchmark test is enabled.

#define | NVSG_LOG_SHADER_TEST_ENABLED() nvutil::LogShaderTest::instance()->isEnabled()
Query if shader 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 Fri Aug 4 08:34:18 2006 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 , TM_BENCH_TEST
00037 , TM_SHADER_TEST
00038 } TESTMODE;
00039
00041 typedef void LOG_OUTPUT_FUNCTION(const char *);
00042 NVSG_API LOG_OUTPUT_FUNCTION logFileOutput;
00043
00044
00046
00049 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00050 class Log
00051 {
00052 public:
00053
00055
00058   Log() : m_enabled(false) {}
00060
00062   void init( bool enable
00063            );
00065
00067   void format( const char * fmt
00068              , ...
00069              ) const;
00071
00073   bool isEnabled() const;
00074
00075 private:
00076   bool m_enabled;
00077 };
00078
00079 // inline implementations
00080
00081 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00082 inline void Log<TestMode, OutputFn>::init(bool enable)
00083 {
00084   m_enabled = enable;
00085 }
00086
00087 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00088 inline void Log<TestMode, OutputFn>::format(const char * fmt, ...) const
00089 {
00090   if ( !m_enabled )
00091   {
00092     return;
00093   }
00094   // walk the parameter list and perform output
00095   const int bufSize = 1024;
00096   char outBuf[bufSize];
00097
00098   va_list ap;
00099   va_start(ap, fmt);
00100   vsnprintf(outBuf, bufSize-1, fmt, ap);
00101   va_end(ap);
00102
00103   OutputFn(outBuf);
00104 }
00105
00106 template <TESTMODE TestMode, LOG_OUTPUT_FUNCTION * OutputFn>
00107 inline bool Log<TestMode, OutputFn>::isEnabled() const
00108 {
00109   return m_enabled;
00110 }
00111
00112 typedef Singleton< Log<TM_TEST,        logFileOutput> > LogTest;
00113 typedef Singleton< Log<TM_BENCH_TEST,  logFileOutput> > LogBenchTest;
00114 typedef Singleton< Log<TM_SHADER_TEST, logFileOutput> > LogShaderTest;
00115 // ... more similar typedefs for additional tests to log
00116
00117 // NVSG_LOG macro defines
00118
00129
00130
00132 #define NVSG_LOG_TEST_INIT(TM)         nvutil::LogTest::instance()->init(TM!=nvutil::TM_NONE)
00133
00134
00136 #define NVSG_LOG_BENCH_TEST_INIT(TM)   nvutil::LogBenchTest::instance()->init(TM==nvutil::TM_BENCH_TEST)
00137
00138
00140 #define NVSG_LOG_SHADER_TEST_INIT(TM)  nvutil::LogShaderTest::instance()->init(TM==nvutil::TM_SHADER_TEST)
00141
00154
00155 #define NVSG_LOG_TEST(s)        { if ( nvutil::LogTest::instance()->isEnabled()       ) { nvutil::LogTest::instance()->format s; }       }
00156
00157 #define NVSG_LOG_BENCH_TEST(s)  { if ( nvutil::LogBenchTest::instance()->isEnabled()  ) { nvutil::LogBenchTest::instance()->format s; }  }
00158
00159 #define NVSG_LOG_SHADER_TEST(s) { if ( nvutil::LogShaderTest::instance()->isEnabled() ) { nvutil::LogShaderTest::instance()->format s; } }
00160
00173
00174 #define NVSG_LOG_TEST_ENABLED()        nvutil::LogTest::instance()->isEnabled()
00175
00176 #define NVSG_LOG_BENCH_TEST_ENABLED()  nvutil::LogBenchTest::instance()->isEnabled()
00177
00178 #define NVSG_LOG_SHADER_TEST_ENABLED() nvutil::LogShaderTest::instance()->isEnabled()
00179
00182 } // namespace nvutil
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:34:18 2006 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 Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


Map.h File Reference

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

Include dependency graph for Map.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 Fri Aug 4 08:34:20 2006 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:
00034       NVSG_API virtual const Map * clone() const = 0;
00035
00039       NVSG_API size_t getWidth() const;
00040
00044       NVSG_API size_t getHeight() const;
00045
00051       NVSG_API const unsigned char * getData() const;
00052
00053     protected:
00061       NVSG_API Map( size_t width
00062                   , size_t height
00063                   , size_t bitsPerPixel
00064                   , unsigned char * data );
00065
00068       NVSG_API Map( const Map &rhs );
00069
00074       NVSG_API virtual ~Map();
00075
00076     private:
00077       Map();  // NOTE: private default constructor to prevent creation without data !
00078
00079
00080     private:
00081       size_t          m_width, m_height;
00082       size_t          m_bpp;  // bits per pixel
00083       unsigned char * m_data;
00084   };
00085
00086   inline size_t Map::getWidth() const
00087   {
00088     NVSG_TRACE();
00089     return( m_width );
00090   }
00091
00092   inline size_t Map::getHeight() const
00093   {
00094     NVSG_TRACE();
00095     return( m_height );
00096   }
00097
00098   inline const unsigned char * Map::getData() const
00099   {
00100     NVSG_TRACE();
00101     return( m_data );
00102   }
00103 }
Generated on Fri Aug 4 08:33:04 2006 for NVSGSDK by NVIDIA


MapArray.h File Reference

#include "nvsgcommon.h"
#include "nvsg/MapObject.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 Fri Aug 4 08:34:21 2006 for NVSGSDK by NVIDIA


MapArray.h Source File

MapArray.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/MapObject.h"
00017 #include <vector>
00018
00019 namespace nvsg
00020 {
00028   class MapArray : public MapObject
00029   {
00030     public:
00038       NVSG_API static const MapArray * create();
00039
00043       NVSG_API virtual const MapArray * clone() const;
00044
00058       NVSG_API MapAlignment getAlignment() const;
00059
00073       NVSG_API void setAlignment( MapAlignment alignment );
00074
00081       NVSG_API MapOrientation getOrientation() const;
00082
00089       NVSG_API void setOrientation( MapOrientation orientation );
00090
00096       NVSG_API size_t getSpacing() const;
00097
00103       NVSG_API void setSpacing( size_t spacing );
00104
00115       NVSG_API MapTraversalDirection getTraversalDirection() const;
00116
00127       NVSG_API void setTraversalDirection( MapTraversalDirection direction );
00128
00132       NVSG_API size_t getNumberOfMaps() const;
00133
00140       NVSG_API const Map * getMap( size_t index ) const;
00141
00147       NVSG_API size_t getIndexOfMap( const Map * map ) const;
00148
00153       NVSG_API void addMap( const Map * map );
00154
00162       NVSG_API void insertMap( size_t index
00163                              , const Map * map );
00164
00173       NVSG_API void replaceMap( size_t index
00174                               , const Map * map );
00175
00182       NVSG_API void removeMap( size_t index );
00183
00188       NVSG_API void clear( void );
00189
00196       NVSG_API void getEntrySize( size_t &width
00197                                 , size_t &height ) const;
00198
00212       NVSG_API virtual void getSize( size_t &width
00213                                    , size_t &height ) const;
00214
00227       NVSG_API virtual const Map * pickMap( int x
00228                                           , int y ) const;
00229
00230     protected:
00233       NVSG_API MapArray();
00234
00238       NVSG_API MapArray( const MapArray &rhs );
00239
00244       NVSG_API virtual ~MapArray();
00245
00251       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00252
00253     private:
00254       MapAlignment              m_alignment;
00255       MapTraversalDirection     m_direction;
00256       std::vector<const Map *>  m_maps;
00257       MapOrientation            m_orientation;
00258       size_t                    m_spacing;
00259   };
00260
00261   inline MapAlignment MapArray::getAlignment() const
00262   {
00263     NVSG_TRACE();
00264     return( m_alignment );
00265   }
00266
00267   inline void MapArray::setAlignment( MapAlignment alignment )
00268   {
00269     NVSG_TRACE();
00270     m_alignment = alignment;
00271   }
00272
00273   inline MapTraversalDirection MapArray::getTraversalDirection() const
00274   {
00275     NVSG_TRACE();
00276     return( m_direction );
00277   }
00278
00279   inline void MapArray::setTraversalDirection( MapTraversalDirection direction )
00280   {
00281     NVSG_TRACE();
00282     m_direction = direction;
00283   }
00284
00285   inline MapOrientation MapArray::getOrientation() const
00286   {
00287     NVSG_TRACE();
00288     return( m_orientation );
00289   }
00290
00291   inline void MapArray::setOrientation( MapOrientation orientation )
00292   {
00293     NVSG_TRACE();
00294     m_orientation = orientation;
00295   }
00296
00297   inline size_t MapArray::getSpacing() const
00298   {
00299     NVSG_TRACE();
00300     return( m_spacing );
00301   }
00302
00303   inline void MapArray::setSpacing( size_t spacing )
00304   {
00305     NVSG_TRACE();
00306     m_spacing = spacing;
00307   }
00308
00309   inline void MapArray::addMap( const Map * map )
00310   {
00311     NVSG_TRACE();
00312     map->addRef();
00313     m_maps.push_back( map );
00314   }
00315
00316   inline void MapArray::insertMap( size_t index, const Map * map )
00317   {
00318     NVSG_TRACE();
00319     NVSG_ASSERT( map && ( index < m_maps.size() ) );
00320     map->addRef();
00321     m_maps.insert( m_maps.begin() + index, map );
00322   }
00323
00324   inline void MapArray::replaceMap( size_t index, const Map * map )
00325   {
00326     NVSG_TRACE();
00327     NVSG_ASSERT( map && ( index < m_maps.size() ) );
00328     map->addRef();
00329     m_maps[index]->removeRef();
00330     m_maps[index] = map;
00331   }
00332
00333   inline void MapArray::removeMap( size_t index )
00334   {
00335     NVSG_TRACE();
00336     NVSG_ASSERT( index < m_maps.size() );
00337     m_maps[index]->removeRef();
00338     m_maps.erase( m_maps.begin() + index );
00339   }
00340
00341   inline size_t MapArray::getNumberOfMaps() const
00342   {
00343     NVSG_TRACE();
00344     return( m_maps.size() );
00345   }
00346
00347   inline const Map * MapArray::getMap( size_t index ) const
00348   {
00349     NVSG_TRACE();
00350     NVSG_ASSERT( index < m_maps.size() );
00351     return( m_maps[index] );
00352   }
00353
00354   inline size_t MapArray::getIndexOfMap( const Map * map ) const
00355   {
00356     NVSG_TRACE();
00357     std::vector<const Map *>::const_iterator it = std::find( m_maps.begin(), m_maps.end(), map );
00358     return( ( it != m_maps.end() ) ? it - m_maps.begin() : -1 );
00359   }
00360
00361 }
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:34:22 2006 for NVSGSDK by NVIDIA


MapElement.h Source File

MapElement.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/MapObject.h"
00017
00018 namespace nvsg
00019 {
00024   class MapElement : public MapObject
00025   {
00026     public:
00032       NVSG_API static const MapElement * create( const Map * m );
00033
00037       NVSG_API virtual const MapElement * clone() const;
00038
00042       NVSG_API const Map * getMap() const;
00043
00048       NVSG_API virtual void getSize( size_t &width, size_t &height ) const;
00049
00059       NVSG_API virtual const Map * pickMap( int x, int y ) const;
00060
00061     protected:
00065       NVSG_API MapElement( const Map *m );
00066
00070       NVSG_API MapElement( const MapElement &rhs );
00071
00076       NVSG_API virtual ~MapElement();
00077
00083       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00084
00085
00086     private:
00087       MapElement();   // private default constructor to prevent explicit creation
00088
00089     private:
00090       const Map * m_map;
00091   };
00092
00093   inline const Map * MapElement::getMap() const
00094   {
00095     NVSG_TRACE();
00096     return( m_map );
00097   }
00098
00099   inline const Map * MapElement::pickMap( int x, int y ) const
00100   {
00101     NVSG_TRACE();
00102     int llx, lly;
00103     getLowerLeft( llx, lly );
00104     return( pointInRect( x, y, llx, lly, llx+m_map->getWidth(), lly+m_map->getHeight() )
00105             ? m_map
00106             : NULL );
00107   }
00108
00109 }
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:34:23 2006 for NVSGSDK by NVIDIA


MapList.h Source File

MapList.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/MapObject.h"
00017 #include "nvsg/Object.h"
00018
00019 namespace nvsg
00020 {
00031   class MapList : public Object
00032   {
00033     public:
00037       NVSG_API static const MapList * create( void );
00038
00042       NVSG_API virtual const MapList * clone( void ) const;
00043
00047       NVSG_API size_t getNumberOfMapObjects( void ) const;
00048
00055       NVSG_API const MapObject * getMapObject( size_t index ) const;
00056
00061       NVSG_API void addMapObject( const MapObject * mo );
00062
00070       NVSG_API void insertMapObject( size_t index
00071                                    , const MapObject * mo );
00072
00081       NVSG_API void replaceMapObject( size_t index
00082                                     , const MapObject * mo );
00083
00090       NVSG_API void removeMapObject( size_t index );
00091
00096       NVSG_API void clear( void );
00097
00110       NVSG_API const Map * pickMap( int x
00111                                   , int y
00112                                   , size_t * index = NULL ) const;
00113
00114     protected:
00117       NVSG_API MapList(void);
00118
00122       NVSG_API MapList( const MapList &rhs );
00123
00128       NVSG_API virtual ~MapList(void);
00129
00135       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00136
00137     private:
00138       std::vector<const MapObject *>  m_list;
00139   };
00140
00141   inline void MapList::addMapObject( const MapObject * mo )
00142   {
00143     NVSG_TRACE();
00144     NVSG_ASSERT( mo );
00145     mo->addRef();
00146     m_list.push_back( mo );
00147   }
00148
00149   inline const MapObject * MapList::getMapObject( size_t index ) const
00150   {
00151     NVSG_TRACE();
00152     NVSG_ASSERT( index < m_list.size() );
00153     return( m_list[index] );
00154   }
00155
00156   inline size_t MapList::getNumberOfMapObjects( void ) const
00157   {
00158     NVSG_TRACE();
00159     return( m_list.size() );
00160   }
00161
00162   inline void MapList::insertMapObject( size_t index, const MapObject * mo )
00163   {
00164     NVSG_TRACE();
00165     NVSG_ASSERT( mo && ( index < m_list.size() ) );
00166     mo->addRef();
00167     m_list.insert( m_list.begin() + index, mo );
00168   }
00169
00170   inline void MapList::removeMapObject( size_t index )
00171   {
00172     NVSG_TRACE();
00173     NVSG_ASSERT( index < m_list.size() );
00174     m_list[index]->removeRef();
00175     m_list.erase( m_list.begin() + index );
00176   }
00177
00178   inline void MapList::replaceMapObject( size_t index, const MapObject * mo )
00179   {
00180     NVSG_TRACE();
00181     NVSG_ASSERT( mo && ( index < m_list.size() ) );
00182     mo->addRef();
00183     m_list[index]->removeRef();
00184     m_list[index] = mo;
00185   }
00186 }
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:34:24 2006 for NVSGSDK by NVIDIA


MapMatrix.h Source File

MapMatrix.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/MapObject.h"
00017 #include <vector>
00018
00019 namespace nvsg
00020 {
00031   class MapMatrix : public MapObject
00032   {
00033     public:
00040       NVSG_API static const MapMatrix * create( void );
00041
00045       NVSG_API virtual const MapMatrix * clone( void ) const;
00046
00059       NVSG_API MapAlignment getAlignment( MapOrientation orientation ) const;
00060
00074       NVSG_API void setAlignment( MapOrientation orientation
00075                                 , MapAlignment alignment );
00076
00084       NVSG_API size_t getSpacing( MapOrientation orientation ) const;
00085
00093       NVSG_API void setSpacing( MapOrientation orientation
00094                               , size_t spacing );
00095
00107       NVSG_API MapTraversalDirection getTraversalDirection( MapOrientation orientation ) const;
00108
00121       NVSG_API void setTraversalDirection( MapOrientation orientation
00122                                          , MapTraversalDirection direction );
00123
00127       NVSG_API size_t getNumberOfColumns( void ) const;
00128
00131       NVSG_API void addEmptyColumn( void );
00132
00138       NVSG_API void insertEmptyColumn( size_t col );
00139
00145       NVSG_API void removeColumn( size_t col );
00146
00151       NVSG_API size_t getNumberOfMaps( size_t col ) const;
00152
00161       NVSG_API const Map * getMap( size_t col
00162                                  , size_t row ) const;
00163
00170       NVSG_API bool getIndexOfMap( const Map * map
00171                                  , size_t & col
00172                                  , size_t & row ) const;
00173
00181       NVSG_API void addMap( size_t col
00182                           , const Map * map );
00183
00193       NVSG_API void insertMap( size_t col
00194                              , size_t row
00195                              , const Map * map );
00196
00207       NVSG_API void replaceMap( size_t col
00208                               , size_t row
00209                               , const Map * map );
00210
00218       NVSG_API void removeMap( size_t col
00219                              , size_t row );
00220
00227       NVSG_API void getEntrySize( size_t &width
00228                                 , size_t &height ) const;
00229
00239       NVSG_API virtual void getSize( size_t &width
00240                                    , size_t &height ) const;
00241
00253       NVSG_API virtual const Map * pickMap( int x
00254                                           , int y ) const;
00255
00256     protected:
00259       NVSG_API MapMatrix( void );
00260
00264       NVSG_API MapMatrix( const MapMatrix &rhs );
00265
00270       NVSG_API virtual ~MapMatrix(void);
00271
00277       NVSG_API virtual void validateIncarnation( void ) const;  // from top to bottom
00278
00279     private:
00280       MapAlignment                            m_alignment[2];
00281       MapTraversalDirection                   m_direction[2];
00282       std::vector<std::vector<const Map *> >  m_maps;
00283       size_t                                  m_spacing[2];
00284   };
00285
00286   inline MapAlignment MapMatrix::getAlignment( MapOrientation orientation ) const
00287   {
00288     NVSG_TRACE();
00289     return( m_alignment[orientation] );
00290   }
00291
00292   inline void MapMatrix::setAlignment( MapOrientation orientation, MapAlignment alignment )
00293   {
00294     NVSG_TRACE();
00295     m_alignment[orientation] = alignment;
00296   }
00297
00298   inline MapTraversalDirection MapMatrix::getTraversalDirection( MapOrientation orientation ) const
00299   {
00300     NVSG_TRACE();
00301     return( m_direction[orientation] );
00302   }
00303
00304   inline void MapMatrix::setTraversalDirection( MapOrientation orientation, MapTraversalDirection direction )
00305   {
00306     NVSG_TRACE();
00307     m_direction[orientation] = direction;
00308   }
00309
00310   inline size_t MapMatrix::getSpacing( MapOrientation orientation ) const
00311   {
00312     NVSG_TRACE();
00313     return( m_spacing[orientation] );
00314   }
00315
00316   inline void MapMatrix::setSpacing( MapOrientation orientation, size_t spacing )
00317   {
00318     NVSG_TRACE();
00319     m_spacing[orientation] = spacing;
00320   }
00321
00322   inline void MapMatrix::addEmptyColumn( void )
00323   {
00324     NVSG_TRACE();
00325     m_maps.resize( m_maps.size() + 1 );
00326   }
00327
00328   inline void MapMatrix::insertEmptyColumn( size_t col )
00329   {
00330     NVSG_TRACE();
00331     NVSG_ASSERT( col < m_maps.size() );
00332     m_maps.insert( m_maps.begin() + col, std::vector<const Map *>() );
00333   }
00334
00335   inline void MapMatrix::addMap( size_t col, const Map * map )
00336   {
00337     NVSG_TRACE();
00338     NVSG_ASSERT( map && ( col < m_maps.size() ) );
00339     map->addRef();
00340     m_maps[col].push_back( map );
00341   }
00342
00343   inline void MapMatrix::insertMap( size_t col, size_t row, const Map * map )
00344   {
00345     NVSG_TRACE();
00346     NVSG_ASSERT( map && ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00347     map->addRef();
00348     m_maps[col].insert( m_maps[col].begin() + row, map );
00349   }
00350
00351   inline void MapMatrix::replaceMap( size_t col, size_t row, const Map * map )
00352   {
00353     NVSG_TRACE();
00354     NVSG_ASSERT( map && ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00355     map->addRef();
00356     m_maps[col][row]->removeRef();
00357     m_maps[col][row] = map;
00358   }
00359
00360   inline void MapMatrix::removeMap( size_t col, size_t row )
00361   {
00362     NVSG_TRACE();
00363     NVSG_ASSERT( ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00364     m_maps[col][row]->removeRef();
00365     m_maps[col].erase( m_maps[col].begin() + row );
00366   }
00367
00368   inline size_t MapMatrix::getNumberOfColumns( void ) const
00369   {
00370     NVSG_TRACE();
00371     return( m_maps.size() );
00372   }
00373
00374   inline size_t MapMatrix::getNumberOfMaps( size_t col ) const
00375   {
00376     NVSG_TRACE();
00377     NVSG_ASSERT( col < m_maps.size() );
00378     return( m_maps[col].size() );
00379   }
00380
00381   inline const Map * MapMatrix::getMap( size_t col, size_t row ) const
00382   {
00383     NVSG_TRACE();
00384     NVSG_ASSERT( ( col < m_maps.size() ) && ( row < m_maps[col].size() ) );
00385     return( m_maps[col][row] );
00386   }
00387
00388 }
Generated on Fri Aug 4 08:33:05 2006 for NVSGSDK by NVIDIA


MapObject.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Map.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 Fri Aug 4 08:34:25 2006 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/Map.h"
00017 #include "nvsg/Object.h"
00018
00019 namespace nvsg
00020 {
00026   typedef enum
00027   {
00028     MA_LOWER,
00029     MA_CENTER,
00030     MA_UPPER
00031   } MapAlignment;
00032
00038   typedef enum
00039   {
00040     MO_HORIZONTAL,
00041     MO_VERTICAL
00042   } MapOrientation;
00043
00049   typedef enum
00050   {
00051     MR_LOWER_LEFT,
00052     MR_LOWER_CENTER,
00053     MR_LOWER_RIGHT,
00054     MR_CENTER_LEFT,
00055     MR_CENTER,
00056     MR_CENTER_RIGHT,
00057     MR_UPPER_LEFT,
00058     MR_UPPER_CENTER,
00059     MR_UPPER_RIGHT
00060   } MapRelation;
00061
00069   typedef enum
00070   {
00071     MTD_LOW_TO_HIGH,
00072     MTD_HIGH_TO_LOW
00073   } MapTraversalDirection;
00074
00082   class MapObject : public Object
00083   {
00084     public:
00088       NVSG_API virtual const MapObject * clone( void ) const = 0;
00089
00098       NVSG_API void getPosition( int & x
00099                                , int & y ) const;
00100
00109       NVSG_API void setPosition( int x
00110                                , int y );
00111
00123       NVSG_API MapRelation getRelation( void ) const;
00124
00136       NVSG_API void setRelation( MapRelation relation );
00137
00150       NVSG_API void getLowerLeft( int & x
00151                                 , int & y ) const;
00152
00161       NVSG_API virtual void getSize( size_t & width
00162                                    , size_t & height ) const = 0;
00163
00169       NVSG_API virtual const Map * pickMap( int x
00170                                           , int y ) const = 0;
00171
00172     protected:
00177       NVSG_API MapObject(void);
00178
00181       NVSG_API MapObject( const MapObject &rhs );
00182
00187       NVSG_API virtual ~MapObject(void);
00188
00189     private:
00190       MapRelation m_relation; // relation of position
00191       int         m_x, m_y;   // raster position
00192   };
00193
00194   inline void MapObject::getPosition( int & x, int & y ) const
00195   {
00196     NVSG_TRACE();
00197     x = m_x;
00198     y = m_y;
00199   }
00200
00201   inline void MapObject::setPosition( int x, int y )
00202   {
00203     NVSG_TRACE();
00204     m_x = x;
00205     m_y = y;
00206   }
00207
00208   inline MapRelation MapObject::getRelation( void ) const
00209   {
00210     NVSG_TRACE();
00211     return( m_relation );
00212   }
00213
00214   inline void MapObject::setRelation( MapRelation relation )
00215   {
00216     NVSG_TRACE();
00217     m_relation = relation;
00218   }
00219
00220 #if ! defined( DOXYGEN_IGNORE )
00221   //  no need to document these tiny helpers
00222   inline bool pointInRect( int x, int y, int llx, int lly, size_t w, size_t h )
00223   {
00224     return( ( llx <= x ) && ( lly <= y ) && ( x <= (int)(llx+w) ) && ( y <= (int)(lly+h) ) );
00225   }
00226
00227   inline bool pointInInterval( int x, int l, size_t s )
00228   {
00229     return( ( l <= x ) && ( x <= (int)(l+s) ) );
00230   }
00231 #endif
00232
00233 }
Generated on Fri Aug 4 08:33:05 2006 for NVSGSDK by NVIDIA


Mat33f.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Matnnf.h"
#include "nvmath/Vec3f.h"

Include dependency graph for Mat33f.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

Defines

#define | NVSG_TRACE_MAT33F(m)

Detailed Description

Define Documentation

#define NVSG_TRACE_MAT33F ( m )

Value:

NVSG_TRACE_OUT_F(( \
    #m " 3x3-matrix output:\n" \
    "\t%f\t%f\t%f\n\t%f\t%f\t%f\n\t%f\t%f\t%f\n" \
    , m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2] ))

Generated on Fri Aug 4 08:34:27 2006 for NVSGSDK by NVIDIA


Mat33f.h Source File

Mat33f.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/Matnnf.h"
00017 #include "nvmath/Vec3f.h"
00018
00019 #if !defined(NDEBUG)
00020 # define NVSG_TRACE_MAT33F(m) \
00021   NVSG_TRACE_OUT_F(( \
00022     #m " 3x3-matrix output:\n" \
00023     "\t%f\t%f\t%f\n\t%f\t%f\t%f\n\t%f\t%f\t%f\n" \
00024     , m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2] ))
00025 #else
00026 # define NVSG_TRACE_MAT33F(m)
00027 #endif
00028
00029 namespace nvmath
00030 {
00031   class Quatf;
00032
00034
00035   class Mat33f : public Matnnf<3>
00036   {
00037     public:
00039
00040       NVSG_API Mat33f( void );
00041
00043
00044       NVSG_API Mat33f( float a00, float a01, float a02
00045                      , float a10, float a11, float a12
00046                      , float a20, float a21, float a22 );
00047
00049
00050       NVSG_API Mat33f( const Vec3f &row0
00051                      , const Vec3f &row1
00052                      , const Vec3f &row2
00053                      );
00054
00056
00057       NVSG_API Mat33f( const Vec3f &axis
00058                      , float rad
00059                      );
00060
00062
00063       NVSG_API Mat33f( const Quatf &quat
00064                      );
00065
00067       NVSG_API Mat33f( const Matnnf<3> & m
00068                      );
00069
00071       NVSG_API void set( const Vec3f &row0
00072                        , const Vec3f &row1
00073                        , const Vec3f &row2
00074                        );
00075   };
00076
00077   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00078   // non-member functions
00079   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00082   NVSG_API void decompose( const Mat33f &mat
00083                          , Quatf &orientation
00084                          , Vec3f &scaling
00085                          , Quatf &scaleOrientation
00086                          );
00087
00091   inline float determinant( const Mat33f &mat
00092                           )
00093   {
00094     return( mat[0] * ( mat[1] ^ mat[2] ) );
00095   }
00096
00101   bool isRotation( const Mat33f &mat
00102                  , float epsilon = FLT_EPSILON
00103                  );
00104
00105   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00106   // inlines
00107   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00108   inline void Mat33f::set( const Vec3f &row0, const Vec3f &row1, const Vec3f &row2 )
00109   {
00110     (*this)[0]=row0;
00111     (*this)[1]=row1;
00112     (*this)[2]=row2;
00113   }
00114
00115 } // end namespace nvmath
Generated on Fri Aug 4 08:33:05 2006 for NVSGSDK by NVIDIA


Mat44f.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Mat33f.h"
#include "nvmath/Vec4f.h"

Include dependency graph for Mat44f.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

Defines

#define | NVSG_TRACE_MAT44F(m)

Detailed Description

Define Documentation

#define NVSG_TRACE_MAT44F ( m )

Value:

NVSG_TRACE_OUT_F(( \
    #m " 4x4-matrix output:\n" \
    "\t%f\t%f\t%f\t%f\n\t%f\t%f\t%f\t%f\n\t%f\t%f\t%f\t%f\n\t%f\t%f\t%f\t%f\n" \
    , m[0][0], m[0][1], m[0][2], m[0][3], m[1][0], m[1][1], m[1][2], m[1][3] \
    , m[2][0], m[2][1], m[2][2], m[2][3], m[3][0], m[3][1], m[3][2], m[3][3] ))

Generated on Fri Aug 4 08:34:28 2006 for NVSGSDK by NVIDIA


Mat44f.h Source File

Mat44f.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/Mat33f.h"
00017 #include "nvmath/Vec4f.h"
00018
00019 #if !defined(NDEBUG)
00020 # define NVSG_TRACE_MAT44F(m) \
00021   NVSG_TRACE_OUT_F(( \
00022     #m " 4x4-matrix output:\n" \
00023     "\t%f\t%f\t%f\t%f\n\t%f\t%f\t%f\t%f\n\t%f\t%f\t%f\t%f\n\t%f\t%f\t%f\t%f\n" \
00024     , m[0][0], m[0][1], m[0][2], m[0][3], m[1][0], m[1][1], m[1][2], m[1][3] \
00025     , m[2][0], m[2][1], m[2][2], m[2][3], m[3][0], m[3][1], m[3][2], m[3][3] ))
00026 #else
00027 # define NVSG_TRACE_MAT44F(m)
00028 #endif
00029
00030 namespace nvmath
00031 {
00033
00034   class Mat44f : public Matnnf<4>
00035   {
00036     public:
00038
00039       NVSG_API Mat44f( void );
00040
00042
00043       NVSG_API Mat44f( float a00, float a01, float a02, float a03
00044                      , float a10, float a11, float a12, float a13
00045                      , float a20, float a21, float a22, float a23
00046                      , float a30, float a31, float a32, float a33 );
00047
00049
00050       NVSG_API Mat44f( const Vec4f &row0
00051                      , const Vec4f &row1
00052                      , const Vec4f &row2
00053                      , const Vec4f &row3
00054                      );
00055
00057
00058       NVSG_API Mat44f( const Vec3f &trans
00059                      , const Quatf &rot
00060                      );
00061
00063
00064       NVSG_API Mat44f( const Vec3f &trans
00065                      , const Quatf &rot
00066                      , const Vec3f &scale
00067                      );
00068
00069
00071       NVSG_API Mat44f( const Matnnf<4> & m
00072                      );
00073
00075       NVSG_API void set( const Vec4f &row0
00076                        , const Vec4f &row1
00077                        , const Vec4f &row2
00078                        , const Vec4f &row3
00079                        );
00080   };
00081
00082   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00083   // non-member functions
00084   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00092   inline  void  decompose( const Mat44f &mat
00093                          , Vec3f &translation
00094                          , Quatf &orientation
00095                          , Vec3f &scaling
00096                          , Quatf &scaleOrientation
00097                          )
00098   {
00099     translation = Vec3f( mat[0][3], mat[1][3], mat[2][3] );
00100     Mat33f  m33( mat[0][0], mat[0][1], mat[0][2],
00101                  mat[1][0], mat[1][1], mat[1][2],
00102                  mat[2][0], mat[2][1], mat[2][2] );
00103     decompose( m33, orientation, scaling, scaleOrientation );
00104   }
00105
00109   NVSG_API const Mat44f operator*( const Mat44f &m0, const Mat44f &m1 );
00110
00112   extern NVSG_API const Mat44f  cIdentity44f;
00113
00114 } // end namespace nvmath
Generated on Fri Aug 4 08:33:05 2006 for NVSGSDK by NVIDIA


Material.h File Reference

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

Include dependency graph for Material.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Fri Aug 4 08:34:29 2006 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/Vec3f.h"
00017 #include "nvsg/StateAttribute.h"
00018
00019
00020 namespace nvsg
00021 {
00022   class Material;
00023
00029   typedef enum
00030   {
00031     MF_FRONT = 0x01,
00032     MF_BACK  = 0x02,
00033     MF_FRONT_AND_BACK = MF_FRONT | MF_BACK
00034   } MaterialFace;
00035
00036 //  ignore private member class on documentation
00037 # if ! defined( DOXYGEN_IGNORE )
00038   class MaterialData : public nvutil::RCObject
00039   {
00040     friend class Material;
00041
00042     public:
00044
00046       NVSG_API MaterialData(const MaterialData& rhs);
00047
00048     private:
00049       // instantiation on stack is not permitted
00050       MaterialData();
00051       ~MaterialData();
00052       // assignment also not permitted
00053       MaterialData& operator=(const MaterialData& rhs) {}
00054
00055       nvmath::Vec3f m_backAmbientColor;
00056       nvmath::Vec3f m_backDiffuseColor;
00057       nvmath::Vec3f m_backEmissiveColor;
00058       float         m_backOpacity;
00059       nvmath::Vec3f m_backSpecularColor;
00060       float         m_backSpecularExponent;
00061
00062       nvmath::Vec3f m_frontAmbientColor;
00063       nvmath::Vec3f m_frontDiffuseColor;
00064       nvmath::Vec3f m_frontEmissiveColor;
00065       float         m_frontOpacity;
00066       nvmath::Vec3f m_frontSpecularColor;
00067       float         m_frontSpecularExponent;
00068   };
00069 #endif    //  DOXYGEN_IGNORE
00070
00083   class Material : public StateAttribute
00084   {
00085     public:
00090       NVSG_API static const Material * create();
00091
00099       NVSG_API static const Material * createFromBase( const StateAttribute &rhs );
00100
00104       NVSG_API virtual const Material * clone() const;
00105
00114       NVSG_API virtual bool isDataShared() const;
00115
00123       NVSG_API virtual DataID getDataID() const;
00124
00136       NVSG_API const nvmath::Vec3f& getAmbientColor( MaterialFace mf = MF_FRONT ) const;
00137
00148       NVSG_API void setAmbientColor( const nvmath::Vec3f &ac
00149                                    , MaterialFace mf = MF_FRONT_AND_BACK );
00150
00166       NVSG_API const nvmath::Vec3f& getDiffuseColor( MaterialFace mf = MF_FRONT ) const;
00167
00182       NVSG_API void setDiffuseColor( const nvmath::Vec3f &dc
00183                                    , MaterialFace mf = MF_FRONT_AND_BACK );
00184
00200       NVSG_API const nvmath::Vec3f& getEmissiveColor( MaterialFace mf = MF_FRONT ) const;
00201
00216       NVSG_API void setEmissiveColor( const nvmath::Vec3f &ec
00217                                     , MaterialFace mf = MF_FRONT_AND_BACK );
00218
00230       NVSG_API float getOpacity( MaterialFace mf = MF_FRONT ) const;
00231
00242       NVSG_API void setOpacity( float o
00243                               , MaterialFace mf = MF_FRONT_AND_BACK );
00244
00257       NVSG_API const nvmath::Vec3f& getSpecularColor( MaterialFace mf = MF_FRONT ) const;
00258
00270       NVSG_API void setSpecularColor( const nvmath::Vec3f &sc
00271                                     , MaterialFace mf = MF_FRONT_AND_BACK );
00272
00285       NVSG_API float getSpecularExponent( MaterialFace mf = MF_FRONT ) const;
00286
00298       NVSG_API void setSpecularExponent( float se
00299                                        , MaterialFace mf = MF_FRONT_AND_BACK );
00300
00306       NVSG_API Material & operator=( const Material & rhs );
00307
00316       NVSG_API virtual bool isEquivalent( const Object * p
00317                                         , bool ignoreNames
00318                                         , bool deepCompare ) const;
00319
00320     protected:
00323       NVSG_API Material();
00324
00331       NVSG_API explicit Material( const StateAttribute &rhs );
00332
00336       NVSG_API Material( const Material &rhs );
00337
00342       NVSG_API virtual ~Material();
00343
00344     private:
00345       nvutil::RCPtr<MaterialData> m_material; // shareable material data
00346   };
00347
00348   inline const nvmath::Vec3f& Material::getAmbientColor( MaterialFace mf ) const
00349   {
00350     NVSG_TRACE();
00351     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00352     return( ( mf & MF_FRONT ) ? m_material->m_frontAmbientColor : m_material->m_backAmbientColor );
00353   }
00354
00355   inline const nvmath::Vec3f& Material::getDiffuseColor( MaterialFace mf ) const
00356   {
00357     NVSG_TRACE();
00358     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00359     return( ( mf & MF_FRONT ) ? m_material->m_frontDiffuseColor : m_material->m_backDiffuseColor );
00360   }
00361
00362   inline const nvmath::Vec3f& Material::getEmissiveColor( MaterialFace mf ) const
00363   {
00364     NVSG_TRACE();
00365     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00366     return( ( mf & MF_FRONT ) ? m_material->m_frontEmissiveColor : m_material->m_backEmissiveColor );
00367   }
00368
00369   inline float Material::getOpacity( MaterialFace mf ) const
00370   {
00371     NVSG_TRACE();
00372     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00373     return( ( mf & MF_FRONT ) ? m_material->m_frontOpacity : m_material->m_backOpacity );
00374   }
00375
00376   inline const nvmath::Vec3f& Material::getSpecularColor( MaterialFace mf ) const
00377   {
00378     NVSG_TRACE();
00379     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00380     return( ( mf & MF_FRONT ) ? m_material->m_frontSpecularColor : m_material->m_backSpecularColor );
00381   }
00382
00383   inline float Material::getSpecularExponent( MaterialFace mf ) const
00384   {
00385     NVSG_TRACE();
00386     NVSG_ASSERT( mf != MF_FRONT_AND_BACK );
00387     return( ( mf & MF_FRONT ) ? m_material->m_frontSpecularExponent : m_material->m_backSpecularExponent );
00388   }
00389
00390 } //  namespace nvsg
00391
Generated on Fri Aug 4 08:33:05 2006 for NVSGSDK by NVIDIA


Matnnf.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnf.h"

Include dependency graph for Matnnf.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 Fri Aug 4 08:34:30 2006 for NVSGSDK by NVIDIA


Matnnf.h Source File

Matnnf.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/Vecnf.h"
00017
00018 namespace nvmath
00019 {
00021
00022   template<unsigned char n> class Matnnf
00023   {
00024     public:
00026
00027       Matnnf<n>( void );
00028
00030
00032       bool  invert( void );
00033
00035
00036       Vecnf<n> & operator[]( size_t i
00037                            );
00038
00040
00041       const Vecnf<n> & operator[]( size_t i
00042                                  ) const;
00043
00045
00046       const Matnnf<n> operator~( void ) const;
00047
00049
00050       const Matnnf<n> operator-( void ) const;
00051
00053
00054       const Matnnf<n> operator*( float f
00055                                ) const;
00056
00058
00059       const Vecnf<n> operator*( const Vecnf<n>& v
00060                               ) const;
00061
00063
00064       const Matnnf<n> operator/( float f
00065                                ) const;
00066
00068
00069       const Matnnf<n> operator+( const Matnnf<n> &v
00070                                ) const;
00071
00073
00074       const Matnnf<n> operator-( const Matnnf<n> &v
00075                                ) const;
00076
00078
00079       bool operator==( const Matnnf<n> &m
00080                      ) const;
00081
00083
00084       bool operator!=( const Matnnf<n> &m
00085                      ) const;
00086
00088
00089       Matnnf<n> & operator=( const Matnnf<n> &m
00090                            );
00091
00093
00094       Matnnf<n> & operator*=( float f
00095                             );
00096
00098
00099       Matnnf<n> & operator*=( const Matnnf<n> &m
00100                            );
00101
00103
00104       Matnnf<n> & operator/=( float f
00105                             );
00106
00108
00109       Matnnf<n> & operator+=( const Matnnf<n> &m
00110                            );
00111
00113
00114       Matnnf<n> & operator-=( const Matnnf<n> &m
00115                            );
00116
00118
00119       const float* getPtr( void ) const;
00120
00121     private:
00122       Vecnf<n>  m_mat[n];
00123   };
00124
00125   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00126   // non-member functions
00127   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00133   template<unsigned char n> bool isIdentity( const Matnnf<n> &m
00134                                            , float epsilon = FLT_EPSILON
00135                                            )
00136   {
00137     bool identity = true;
00138     for ( size_t i=0 ; identity && i<n ; i++ )
00139     {
00140       for ( size_t j=0 ; identity && j<i ; j++ )
00141       {
00142         identity = ( fabsf( m[i][j] ) <= epsilon );
00143       }
00144       if ( identity )
00145       {
00146         identity = ( fabsf( m[i][i] - 1.0f ) <= epsilon );
00147       }
00148       for ( size_t j=i+1 ; identity && j<n ; j++ )
00149       {
00150         identity = ( fabsf( m[i][j] ) <= epsilon );
00151       }
00152     }
00153     return( identity );
00154   }
00155
00160   template<unsigned char n> bool isNormalized( const Matnnf<n> &mat
00161                                              , float epsilon = FLT_EPSILON
00162                                              )
00163   {
00164     bool normalized = true;
00165     for ( size_t i=0 ; normalized && i<n ; i++ )
00166     {
00167       normalized = isNormalized( mat[i], epsilon );
00168     }
00169     for ( size_t i=0 ; normalized && i<n ; i++ )
00170     {
00171       Vecnf<n> v;
00172       for ( size_t j=0 ; j<n ; j++ )
00173       {
00174         v[j] = mat[j][i];
00175       }
00176       normalized = isNormalized( v, epsilon );
00177     }
00178     return( normalized );
00179   }
00180
00185   template<unsigned char n> bool isNull( const Matnnf<n> &mat
00186                                        , float epsilon = FLT_EPSILON
00187                                        )
00188   {
00189     bool null = true;
00190     for ( size_t i=0 ; null && i<n ; i++ )
00191     {
00192       null = isNull( mat[i], epsilon );
00193     }
00194     return( null );
00195   }
00196
00202   template<unsigned char n> bool isOrthogonal( const Matnnf<n> &mat
00203                                              , float epsilon = FLT_EPSILON
00204                                              )
00205   {
00206     bool orthogonal = true;
00207     for ( size_t i=0 ; orthogonal && i<n-1 ; i++ )
00208     {
00209       for ( size_t j=i+1 ; orthogonal && j<n ; j++ )
00210       {
00211         orthogonal = areOrthogonal( mat[i], mat[j], epsilon );
00212       }
00213     }
00214     if ( orthogonal )
00215     {
00216       Matnnf<n> tmp = ~mat;
00217       for ( size_t i=0 ; orthogonal && i<n-1 ; i++ )
00218       {
00219         for ( size_t j=i+1 ; orthogonal && j<n ; j++ )
00220         {
00221           orthogonal = areOrthogonal( tmp[i], tmp[j], epsilon );
00222         }
00223       }
00224     }
00225     return( orthogonal );
00226   }
00227
00231   template<unsigned char n> const Matnnf<n> operator*( float f, const Matnnf<n> &m )
00232   {
00233     return( m * f );
00234   }
00235
00239   template<unsigned char n> const Matnnf<n> operator*( const Matnnf<n> &m0, const Matnnf<n> &m1 )
00240   {
00241     Matnnf<n> ret;
00242     for ( size_t i=0 ; i<n ; i++ )
00243     {
00244       for ( size_t j=0 ; j<n ; j++ )
00245       {
00246         double sum = 0.0;
00247         for ( size_t k=0 ; k<n ; k++ )
00248         {
00249           sum += m0[i][k] * m1[k][j];
00250         }
00251         ret[i][j] = (float)sum;
00252       }
00253     }
00254     return( ret );
00255   }
00256
00259   template<unsigned char n> void setIdentity( Matnnf<n> &m )
00260   {
00261     for ( size_t i=0 ; i<n ; i++ )
00262     {
00263       for ( size_t j=0 ; j<n ; j++ )
00264       {
00265         m[i][j] = 0.0f;
00266       }
00267       m[i][i] = 1.0f;
00268     }
00269   }
00270
00271   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00272   // "inlines"
00273   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00274   template<unsigned char n> Matnnf<n>::Matnnf( void )
00275   {
00276   }
00277
00278   template<unsigned char n> bool Matnnf<n>::invert( void )
00279   {
00280     size_t  p[n];
00281
00282     bool ok = true;
00283     for ( size_t k=0 ; k<n && ok ; k++ )
00284     {
00285       float max = 0.0f;
00286       p[k] = 0;
00287       for ( size_t i=k ; i<n && ok ; i++ )
00288       {
00289         float s = 0.0f;
00290         for ( size_t j=k ; j<n ; j++ )
00291         {
00292           s += fabsf( m_mat[i][j] );
00293         }
00294         ok = ( FLT_EPSILON < fabsf(s) );
00295         if ( ok )
00296         {
00297           float q = fabsf( m_mat[i][k] ) / s;
00298           if ( q > max )
00299           {
00300             max = q;
00301             p[k] = i;
00302           }
00303         }
00304       }
00305
00306       ok = ( FLT_EPSILON < max );
00307       if ( ok )
00308       {
00309         if ( p[k] != k )
00310         {
00311           for ( size_t j=0 ; j<n ; j++ )
00312           {
00313             std::swap( m_mat[k][j], m_mat[p[k]][j] );
00314           }
00315         }
00316
00317         float pivot = m_mat[k][k];
00318         ok = ( FLT_EPSILON < fabsf( pivot ) );
00319         if ( ok )
00320         {
00321           for ( size_t j=0 ; j<n ; j++ )
00322           {
00323             if ( j != k )
00324             {
00325               m_mat[k][j] /= - pivot;
00326               for ( size_t i=0 ; i<n ; i++ )
00327               {
00328                 if ( i != k )
00329                 {
00330                   m_mat[i][j] += m_mat[i][k] * m_mat[k][j];
00331                 }
00332               }
00333             }
00334           }
00335
00336           for ( size_t i=0 ; i<n ; i++ )
00337           {
00338             m_mat[i][k] /= pivot;
00339           }
00340           m_mat[k][k] = 1.0f / pivot;
00341         }
00342       }
00343     }
00344
00345     if ( ok )
00346     {
00347       for ( size_t k=n-2 ; k<n ; k-- )  //  NOTE: ( size_t k < n ) <=> ( int k >= 0 )
00348       {
00349         if ( p[k] != k )
00350         {
00351           for ( size_t i=0 ; i<n ; i++ )
00352           {
00353             std::swap( m_mat[i][k], m_mat[i][p[k]] );
00354           }
00355         }
00356       }
00357     }
00358
00359     return( ok );
00360   }
00361
00362   template<unsigned char n> Vecnf<n> & Matnnf<n>::operator[]( size_t i )
00363   {
00364     NVSG_ASSERT( 0 <= i && i < n );
00365     return( m_mat[i] );
00366   }
00367
00368   template<unsigned char n> const Vecnf<n> & Matnnf<n>::operator[]( size_t i ) const
00369   {
00370     NVSG_ASSERT( 0 <= i && i < n );
00371     return( m_mat[i] );
00372   }
00373
00374   template<unsigned char n> const Matnnf<n> Matnnf<n>::operator~( void ) const
00375   {
00376     Matnnf<n> ret;
00377     for ( size_t i=0 ; i<n ; i++ )
00378     {
00379       for ( size_t j=0 ; j<n ; j++ )
00380       {
00381         ret[i][j] = m_mat[j][i];
00382       }
00383     }
00384     return( ret );
00385   }
00386
00387   template<unsigned char n> const Matnnf<n> Matnnf<n>::operator-( void ) const
00388   {
00389     Matnnf<n> ret;
00390     for ( size_t i=0 ; i<n ; i++ )
00391     {
00392       ret[i] = - m_mat[i];
00393     }
00394     return( ret );
00395   }
00396
00397   template<unsigned char n> const Matnnf<n> Matnnf<n>::operator*( float f ) const
00398   {
00399     Matnnf<n> ret( *this );
00400     return( ret *= f );
00401   }
00402
00403   template<unsigned char n> const Vecnf<n> Matnnf<n>::operator*( const Vecnf<n> &v ) const
00404   {
00405     Vecnf<n>  ret;
00406     for ( size_t i=0 ; i<n ; i++ )
00407     {
00408       ret[i] = m_mat[i] * v;
00409     }
00410     return( ret );
00411   }
00412
00413   template<unsigned char n> const Matnnf<n> Matnnf<n>::operator/( float f ) const
00414   {
00415     NVSG_ASSERT( FLT_EPSILON < fabs( f ) );
00416     Matnnf<n> ret( *this );
00417     return( ret /= f );
00418   }
00419
00420   template<unsigned char n> const Matnnf<n> Matnnf<n>::operator+( const Matnnf<n> &m ) const
00421   {
00422     Matnnf<n> ret( *this );
00423     return( ret += m );
00424   }
00425
00426   template<unsigned char n> const Matnnf<n> Matnnf<n>::operator-( const Matnnf<n> &m ) const
00427   {
00428     Matnnf<n> ret( *this );
00429     return( ret -= m );
00430   }
00431
00432   template<unsigned char n> bool Matnnf<n>::operator==( const Matnnf<n> &m ) const
00433   {
00434     bool equal = true;
00435     for ( unsigned char i=0 ; equal && i<n ; i++ )
00436     {
00437       equal = ( m_mat[i] == m[i] );
00438     }
00439     return( equal );
00440   }
00441
00442   template<unsigned char n> bool Matnnf<n>::operator!=( const Matnnf<n> &m ) const
00443   {
00444     return( ! ( *this == m ) );
00445   }
00446
00447   template<unsigned char n> Matnnf<n> & Matnnf<n>::operator=( const Matnnf<n> &m )
00448   {
00449     for ( size_t i=0 ; i<n ; i++ )
00450     {
00451       m_mat[i] = m[i];
00452     }
00453     return( *this );
00454   }
00455
00456   template<unsigned char n> Matnnf<n> & Matnnf<n>::operator*=( float f )
00457   {
00458     for ( size_t i=0 ; i<n ; i++ )
00459     {
00460       m_mat[i] *= f;
00461     }
00462     return( *this );
00463   }
00464
00465   template<unsigned char n> Matnnf<n> & Matnnf<n>::operator*=( const Matnnf<n> &m )
00466   {
00467     *this = *this * m;
00468     return( *this );
00469   }
00470
00471   template<unsigned char n> Matnnf<n> & Matnnf<n>::operator/=( float f )
00472   {
00473     NVSG_ASSERT( FLT_EPSILON < fabs( f ) );
00474     for ( size_t i=0 ; i<n ; i++ )
00475     {
00476       m_mat[i] /= f;
00477     }
00478     return( *this );
00479   }
00480
00481   template<unsigned char n> Matnnf<n> & Matnnf<n>::operator+=( const Matnnf<n> &m )
00482   {
00483     for ( size_t i=0 ; i<n ; i++ )
00484     {
00485       m_mat[i] += m[i];
00486     }
00487     return( *this );
00488   }
00489
00490   template<unsigned char n> Matnnf<n> & Matnnf<n>::operator-=( const Matnnf<n> &m )
00491   {
00492     for ( size_t i=0 ; i<n ; i++ )
00493     {
00494       m_mat[i] -= m[i];
00495     }
00496     return( *this );
00497   }
00498
00499   template<unsigned char n> const float * Matnnf<n>::getPtr( void ) const
00500   {
00501     return( m_mat[0].getPtr() );
00502   }
00503
00504 } // end namespace nvmath
Generated on Fri Aug 4 08:33:05 2006 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 Fri Aug 4 08:34:32 2006 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 {
00028   class MeshedPrimitiveSet : public PrimitiveSet
00029   {
00030     public:
00040       NVSG_API virtual bool isDataShared() const;
00041
00049       NVSG_API virtual DataID getDataID() const;
00050
00054       NVSG_API bool hasMeshes()  const;
00055
00059       NVSG_API size_t getNumberOfMeshes() const;
00060
00064       NVSG_API const IndexMesh * getMeshes() const;
00065
00073       NVSG_API void setMeshes( const IndexMesh * meshes
00074                              , size_t numMeshes );
00075
00092       NVSG_API void setMeshes( size_t pos
00093                              , const IndexMesh * meshes
00094                              , size_t numMeshes
00095                              );
00096
00100       NVSG_API virtual const MeshedPrimitiveSet * clone() const = 0;
00101
00111       NVSG_API virtual bool isEquivalent( const Object * p
00112                                         , bool ignoreNames
00113                                         , bool deepCompare ) const;
00114
00115     protected:
00120       NVSG_API MeshedPrimitiveSet();
00121
00127       NVSG_API MeshedPrimitiveSet( const MeshedPrimitiveSet& rhs );
00128
00133       NVSG_API virtual ~MeshedPrimitiveSet();
00134
00139       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00140
00146       NVSG_API MeshedPrimitiveSet & operator=(const MeshedPrimitiveSet & rhs);
00147
00148     private:
00149       nvutil::RCPtr<nvutil::RCVector<IndexMesh> > m_meshes;
00150   };
00151
00152
00153   // - - - - - - - - - - - - - - - - - - - - - - - - -
00154   // inlines
00155   // - - - - - - - - - - - - - - - - - - - - - - - - -
00156
00157   inline bool MeshedPrimitiveSet::hasMeshes()  const
00158   {
00159     return( !m_meshes->empty() );
00160   }
00161
00162   inline size_t MeshedPrimitiveSet::getNumberOfMeshes()  const
00163   {
00164     return( m_meshes->size() );
00165   }
00166
00167   inline const IndexMesh * MeshedPrimitiveSet::getMeshes() const
00168   {
00169     NVSG_TRACE();
00170     return( &(*m_meshes)[0] );
00171   }
00172 }
Generated on Fri Aug 4 08:33:05 2006 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 Fri Aug 4 08:34:33 2006 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 ModelViewTraverser : public Traverser
00030   {
00031     public:
00033
00035       NVSG_API virtual void setViewState( const nvsg::ViewState * viewState
00036                                         );
00037     protected:
00039
00041       NVSG_API ModelViewTraverser( bool readOnly = true );
00042
00044       NVSG_API virtual ~ModelViewTraverser();
00045
00047
00048       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00049                                                   );
00050
00052
00054       NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00055                                            );
00056
00057       NVSG_API virtual void handleLOD( const nvsg::LOD *p );
00058
00060
00061       NVSG_API virtual void handleParallelCamera( const nvsg::ParallelCamera *p
00062                                                 , const nvsg::Node *root
00063                                                 );
00064
00066
00067       NVSG_API virtual void handlePerspectiveCamera( const nvsg::PerspectiveCamera *p
00068                                                   , const nvsg::Node *root
00069                                                   );
00070
00072
00074       NVSG_API virtual void handleTransform( const nvsg::Transform *p
00075                                           );
00076
00078
00079       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00080                                                 );
00081
00083
00085       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00086                                                 );
00087
00089
00090       NVSG_API virtual bool preTraverseRoot( const nvsg::Camera *p
00091                                           , const nvsg::Node *root
00092                                           );
00093
00094
00095     protected:
00096       nvmath::Vec3f           m_cameraPosition;
00097       nvmath::Vec3f           m_cameraUpVector;
00098       nvutil::TransformStack  m_transformStack;
00099   };
00100 }
Generated on Fri Aug 4 08:33:05 2006 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 | 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 transfrmation 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 | 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 | NBFTrafoAnimation
The NBFTrafoAnimation represents an animation that will be applied to trafo_t objects. More...

struct | NBFVNVectorAnimation
The NBFVNVectorAnimation represents an animation that will be applied to VNVector objects. More...

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

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

struct | NBFFramedVNVectorAnimation
The NBFFramedVNVectorAnimation structure represents a framed animation that will be applied to VNVector 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 | NBFInterpolatedVNVectorAnimation
The NBFInterpolatedVNVectorAnimation structure represents a interpolated animation that will be applied to VNVector 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 | 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 | NBFAnimatedIndependents
The NBFAnimatedIndependents structure represents animated independent primitives. 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 | 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 | 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 | 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 | 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...

Defines

#define | __NVSG_CTASSERT_PREFIX NBF_H
#define | PADDING(n) PADDING_i(n,__LINE__)
#define | PADDING_i(n, l) PADDING_ii(n,l)
#define | PADDING_ii(n, l) ubyte_t padding##l[n]

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 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.

Enumerations

enum {
NBF_UNKNOWN = 0x00000000, NBF_TRAFO_ANIMATION = 0x00000100, NBF_VNVECTOR_ANIMATION, NBF_FRAMED_ANIMATION = 0x00000120,
NBF_FRAMED_TRAFO_ANIMATION, NBF_FRAMED_VNVECTOR_ANIMATION, NBF_INTERPOLATED_ANIMATION = 0x00000140, NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION,
NBF_LINEAR_INTERPOLATED_VNVECTOR_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_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_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_CUSTOM_OBJECT
}
Unique NBF Object Codes. More...

Functions

NVSG_CTASSERT (sizeof(str_t)%4==0)
NVSG_CTASSERT (sizeof(texCoordSet_t)%4==0)
NVSG_CTASSERT (sizeof(geometrySet_t)%4==0)
NVSG_CTASSERT (sizeof(indexSet_t)%4==0)
test size of struct

NVSG_CTASSERT (sizeof(texBinding_t)%4==0)
NVSG_CTASSERT (sizeof(texImage_t)%4==0)
NVSG_CTASSERT (sizeof(trafo_t)%4==0)
NVSG_CTASSERT (sizeof(tweak_t)%4==0)
NVSG_CTASSERT (sizeof(bone_t)%4==0)
NVSG_CTASSERT (sizeof(skin_t)%4==0)
NVSG_CTASSERT (sizeof(keyVariant_t)%4==0)
NVSG_CTASSERT (sizeof(NBFHeader)%4==0)
NVSG_CTASSERT (sizeof(NBFScene)%4==0)
NVSG_CTASSERT (sizeof(NBFViewState)%4==0)
NVSG_CTASSERT (sizeof(NBFObject)%8==0)
NVSG_CTASSERT (sizeof(NBFTrafoAnimation)%8==0)
NVSG_CTASSERT (sizeof(NBFVNVectorAnimation)%8==0)
NVSG_CTASSERT (sizeof(NBFFramedAnimation)%4==0)
NVSG_CTASSERT (sizeof(NBFFramedTrafoAnimation)%8==0)
NVSG_CTASSERT (sizeof(NBFFramedVNVectorAnimation)%8==0)
NVSG_CTASSERT (sizeof(NBFInterpolatedAnimation)%4==0)
NVSG_CTASSERT (sizeof(NBFInterpolatedTrafoAnimation)%8==0)
NVSG_CTASSERT (sizeof(NBFInterpolatedVNVectorAnimation)%8==0)
NVSG_CTASSERT (sizeof(NBFCamera)%8==0)
NVSG_CTASSERT (sizeof(NBFParallelCamera)%8==0)
NVSG_CTASSERT (sizeof(NBFPerspectiveCamera)%8==0)
NVSG_CTASSERT (sizeof(NBFDrawable)%8==0)
NVSG_CTASSERT (sizeof(NBFVertexAttributeSet)%8==0)
NVSG_CTASSERT (sizeof(NBFPrimitiveSet)%8==0)
NVSG_CTASSERT (sizeof(NBFIndependentPrimitiveSet)%8==0)
NVSG_CTASSERT (sizeof(NBFMeshedPrimitiveSet)%8==0)
test size of struct

NVSG_CTASSERT (sizeof(NBFStrippedPrimitiveSet)%8==0)
NVSG_CTASSERT (sizeof(NBFAnimatedIndependents)%8==0)
NVSG_CTASSERT (sizeof(NBFSkinnedTriangles)%8==0)
NVSG_CTASSERT (sizeof(NBFNode)%8==0)
NVSG_CTASSERT (sizeof(NBFGeoNode)%8==0)
NVSG_CTASSERT (sizeof(NBFGroup)%8==0)
NVSG_CTASSERT (sizeof(NBFLOD)%8==0)
NVSG_CTASSERT (sizeof(NBFSwitch)%8==0)
NVSG_CTASSERT (sizeof(NBFBillboard)%8==0)
NVSG_CTASSERT (sizeof(NBFTransform)%8==0)
NVSG_CTASSERT (sizeof(NBFAnimatedTransform)%8==0)
NVSG_CTASSERT (sizeof(NBFLightSource)%8==0)
NVSG_CTASSERT (sizeof(NBFDirectedLight)%8==0)
NVSG_CTASSERT (sizeof(NBFPointLight)%8==0)
NVSG_CTASSERT (sizeof(NBFSpotLight)%8==0)
NVSG_CTASSERT (sizeof(NBFStateSet)%8==0)
NVSG_CTASSERT (sizeof(NBFStateVariant)%8==0)
NVSG_CTASSERT (sizeof(NBFStatePass)%8==0)
NVSG_CTASSERT (sizeof(NBFStateAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFBlendAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFCgFx)%8==0)
NVSG_CTASSERT (sizeof(NBFDepthAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFFaceAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFLineAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFMaterial)%8==0)
NVSG_CTASSERT (sizeof(NBFPointAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFTextureAttribute)%8==0)
NVSG_CTASSERT (sizeof(NBFTextureAttributeItem)%8==0)

Variables

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

const ubyte_t | NBF_VER_MINOR = 0x05
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

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.

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.

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 | Identifies an NBFFramedVNVectorAnimation object.
NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION | Identifies an NBFInterpolatedTrafoAnimation object.
NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION | Identifies an NBFInterpolatedVNVectorAnimation object.
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 | Identifies an NBFAnimatedIndependents object.
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 | Identifies an NBFAnimatedIndependents object (support since v0.4).
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_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_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_CUSTOM_OBJECT | Custom objects must not have codes lower than this.

Function Documentation

NVSG_CTASSERT ( sizeof(indexSet_t)% 4 = =0 )

test size of struct

NVSG_CTASSERT ( sizeof(NBFMeshedPrimitiveSet)% 8 = =0 )

test size of struct

Variable Documentation

const ubyte_t NBF_VER_MAJOR = 0x13

NBF major version number.

const ubyte_t NBF_VER_MINOR = 0x05

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 Fri Aug 4 08:34:34 2006 for NVSGSDK by NVIDIA


NBF.h Source File

NBF.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/BitMask.h"
00017
00018
00019 #define __NVSG_CTASSERT_PREFIX    NBF_H
00020
00021 // NBF is independent of packing. However, this forces
00022 // the compile-time asserts below to fire on inconsistencies
00023 #pragma pack(push, 1)
00024
00025 // convenient aliases for used built-in types
00026 typedef char                    byte_t;
00027 typedef unsigned char           ubyte_t;
00028 typedef int                     int_t;
00029 typedef unsigned int            uint_t;
00030 #ifdef LINUX
00031 # if __WORDSIZE == 64           // defined indirectly through stdint.h
00032 // avoid a conflict with GNU stdint.h on Linux64
00033 // note: long is a 64-bit type on Linux64, while it is 32bit on Win64
00034 // Linux64
00035 typedef unsigned long           uint64_t;
00036 # else
00037 // Linux32
00038 typedef unsigned long long      uint64_t;
00039 # endif
00040 #else
00041 // Win32 and Win64
00042 typedef unsigned long long      uint64_t;
00043 #endif
00044 typedef float                   float2_t[2];
00045 typedef float                   float3_t[3];
00046 typedef float                   float4_t[4];
00047
00048 // convenient macro to add padding bits
00049 #define PADDING(n) PADDING_i(n,__LINE__)
00050 #define PADDING_i(n,l) PADDING_ii(n,l)
00051 #define PADDING_ii(n,l) ubyte_t padding##l[n]
00052
00053 // NBF version
00054 const ubyte_t NBF_VER_MAJOR  =  0x13;
00055 const ubyte_t NBF_VER_MINOR  =  0x05;
00056 const ubyte_t NBF_VER_BUGFIX =  0x00;
00057
00058 // constants specifying a certain byte order
00059 const ubyte_t NBF_LITTLE_ENDIAN = 0x00;
00060 const ubyte_t NBF_BIG_ENDIAN =  0x01;
00061
00062 // convenient helper types
00063
00065 struct str_t
00066 {
00067   uint_t      numChars;
00068
00069   uint_t      chars;
00070 };
00071 NVSG_CTASSERT(sizeof(str_t)%4==0);
00072
00074
00075 struct texCoordSet_t
00076 {
00077   uint_t      numTexCoords;
00078   uint_t      coordDim;
00079
00080   uint_t      texCoords;
00081 };
00082 NVSG_CTASSERT(sizeof(texCoordSet_t)%4==0);
00083
00085
00086 struct geometrySet_t
00087 {
00088   uint_t      stateSet;
00089   uint_t      numDrawables;
00090   uint_t      drawables;
00091 };
00092 NVSG_CTASSERT(sizeof(geometrySet_t)%4==0);
00093
00095
00096 struct indexSet_t
00097 {
00098   uint_t      numIndices;
00099   uint_t      indices;
00100
00101 };
00102 NVSG_CTASSERT(sizeof(indexSet_t)%4==0);
00103
00105
00106 struct meshSet_t
00107 {
00108   uint_t      width;
00109   uint_t      height;
00110   uint_t      indices;
00111
00112 };
00113 NVSG_CTASSERT(sizeof(indexSet_t)%4==0);
00114
00116
00118 struct texBinding_t
00119 {
00120   uint_t      texUnit;
00121   uint_t      texAttribItem;
00122 };
00123 NVSG_CTASSERT(sizeof(texBinding_t)%4==0);
00124
00126
00127 struct texImage_t
00128 {
00129   uint_t      flags;
00130   str_t       file;
00131   // the following are only relevant in case the image is not from a file but from a image data lump.
00132   uint_t      width;
00133   uint_t      height;
00134   uint_t      depth;
00135   uint_t      bpp;
00136   uint_t      bps;
00137   uint_t      bpi;
00138   uint_t      pixelFormat;
00139   uint_t      dataType;
00140   uint_t      pixels;
00141 };
00142 NVSG_CTASSERT(sizeof(texImage_t)%4==0);
00143
00145 struct trafo_t
00146 {
00147   float4_t    orientation;
00148   float3_t    scaling;
00149   float3_t    translation;
00150   float3_t    center;
00151   float4_t    scaleOrientation;
00152 };
00153 NVSG_CTASSERT(sizeof(trafo_t)%4==0);
00154
00156
00157 struct tweak_t
00158 {
00159   str_t       name;
00160
00161   // type flags
00162   enum {
00163     TYPE_STRUCT = BIT0
00164   , TYPE_ARRAY  = BIT1
00165   , TYPE_FLOAT  = BIT2
00166   , TYPE_INT    = BIT3
00167   , TYPE_BOOL   = BIT4
00168   , TYPE_STRING = BIT5
00169   };
00170   uint_t      type;
00171   uint_t      numValues;
00173   union
00174   {
00175     uint_t    floats;
00178     str_t     str;
00179   };
00180
00181   // the following is relevant only for arrays and structs (nesting tweaks)
00182   uint_t   numTweaks;
00184   uint_t   tweaks;
00185 };
00186 NVSG_CTASSERT(sizeof(tweak_t)%4==0);
00187
00189
00190 struct sampler_t
00191 {
00192   str_t       name;
00193   uint_t      texImg;
00194 };
00195
00197
00198 struct bone_t
00199 {
00200   float       weight;
00201
00202   uint_t      animation;
00203
00204 };
00205 NVSG_CTASSERT(sizeof(bone_t)%4==0);
00206
00208
00209 struct skin_t
00210 {
00211   uint_t      numBones;
00212   uint_t      bones;
00213
00214   float3_t    vertex;
00215   float3_t    normal;
00216 };
00217 NVSG_CTASSERT(sizeof(skin_t)%4==0);
00218
00220 struct keyVariant_t
00221 {
00222   uint_t      key;
00223   uint_t      variant;
00224 };
00225 NVSG_CTASSERT(sizeof(keyVariant_t)%4==0);
00226
00228 struct plane_t
00229 {
00230   uint_t      active;
00231   float3_t    normal;
00232   float       offset;
00233 };
00234
00236
00240 enum
00241 {
00242   // scene object
00243   NBF_UNKNOWN                     = 0x00000000
00244   // animation objects (0x100 - 0x1FF)
00245 , NBF_TRAFO_ANIMATION           = 0x00000100
00246 , NBF_VNVECTOR_ANIMATION
00247   // framed animations
00248 , NBF_FRAMED_ANIMATION          = 0x00000120
00249 , NBF_FRAMED_TRAFO_ANIMATION
00250 , NBF_FRAMED_VNVECTOR_ANIMATION
00251   // interpolated animations
00252 , NBF_INTERPOLATED_ANIMATION    = 0x00000140
00253 , NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION
00254 , NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION
00255   // camera objects (0x200 - 0x2FF)
00256 , NBF_CAMERA                    = 0x00000200
00257 , NBF_MONO_CAMERA
00258 , NBF_JITTER_CAMERA
00259 , NBF_SIMPLE_CAMERA
00260 , NBF_PARALLEL_CAMERA
00261 , NBF_PERSPECTIVE_CAMERA
00262 , NBF_STEREO_CAMERA
00263   // drawable objects (0x300 - 0x3FF)
00264 , NBF_DRAWABLE                  = 0x00000300
00265 , NBF_VERTEX_ATTRIBUTE_SET
00266 , NBF_TRIANGLES
00267 , NBF_ANIMATED_TRIANGLES
00268 , NBF_SKINNED_TRIANGLES
00269 , NBF_TRISTRIPS
00270 , NBF_QUADS
00271 , NBF_ANIMATED_QUADS
00272 , NBF_QUADSTRIPS
00273 , NBF_LINES
00274 , NBF_LINESTRIPS
00275 , NBF_TRIFANS
00276 , NBF_POINTS
00277 , NBF_QUADMESHES
00278   // node objects (0x400 - 0x4FF)
00279 , NBF_NODE                      = 0x00000400
00280 , NBF_GEO_NODE
00281 , NBF_GROUP
00282 , NBF_LOD
00283 , NBF_SWITCH
00284 , NBF_TRANSFORM
00285 , NBF_ANIMATED_TRANSFORM
00286 , NBF_LIGHT_SOURCE
00287 , NBF_DIRECTED_LIGHT
00288 , NBF_POINT_LIGHT
00289 , NBF_SPOT_LIGHT
00290 , NBF_BILLBOARD
00291   // state set objects (0x500 - 0x5FF)
00292 , NBF_STATE_SET                 = 0x00000500
00293 , NBF_STATE_VARIANT
00294 , NBF_STATE_PASS
00295   // state attribute objects (0x600 - 0x6FF)
00296 , NBF_STATE_ATTRIBUTE           = 0x00000600
00297 , NBF_CGFX
00298 , NBF_MATERIAL
00299 , NBF_FACE_ATTRIBUTE
00300 , NBF_TEXTURE_ATTRIBUTE
00301 , NBF_TEXTURE_ATTRIBUTE_ITEM
00302 , NBF_LINE_ATTRIBUTE
00303 , NBF_POINT_ATTRIBUTE
00304 , NBF_BLEND_ATTRIBUTE
00305 , NBF_DEPTH_ATTRIBUTE
00306   // custom objects (>=0x700)
00307 , NBF_CUSTOM_OBJECT
00308 };
00309
00311
00317 struct NBFHeader
00318 {
00319   // signature
00320   byte_t      signature[4];
00321   // NBF version
00322   ubyte_t     nbfMajorVersion;
00323   ubyte_t     nbfMinorVersion;
00324   ubyte_t     nbfBugfixLevel;
00325
00326
00327   // NVSG version
00328   ubyte_t     nvsgMajorVersion;
00329   ubyte_t     nvsgMinorVersion;
00330   ubyte_t     nvsgBugfixLevel;
00331
00332
00333   // Reserved bytes
00334   ubyte_t     reserved[16];
00335   // Date
00336   ubyte_t     dayLastModified;
00337   ubyte_t     monthLastModified;
00338   ubyte_t     yearLastModified[2];
00339   // Time stamp
00340   ubyte_t     secondLastModified;
00341   ubyte_t     minuteLastModified;
00342   ubyte_t     hourLastModified;
00343   // endianess
00344   ubyte_t     byteOrder;
00345
00346
00347   PADDING(2);
00348   // scene object
00349   uint_t      scene;
00350   // optional view state
00351   uint_t      viewState;
00352
00353 };
00354 NVSG_CTASSERT(sizeof(NBFHeader)%4==0);
00355
00357
00359 struct NBFScene
00360 {
00361   float3_t    ambientColor;
00362   float3_t    backColor;
00363   uint_t      numCameras;
00364   uint_t      cameras;
00365   uint_t      numCameraAnimations;
00366   uint_t      cameraAnimations;
00367   uint_t      numberOfAnimationFrames;
00368   uint_t      root;
00369 };
00370 NVSG_CTASSERT(sizeof(NBFScene)%4==0);
00371
00373
00374 struct NBFViewState
00375 {
00376   uint_t      objectCode;
00377   uint_t      camera;
00378   ubyte_t     isJitter;
00379   ubyte_t     isStereo;
00380   ubyte_t     isStereoAutomatic;
00381   PADDING(1);
00382   uint_t      numJitters;
00383   uint_t      jitters;
00384   float       stereoAutomaticFactor;
00385   float       stereoEyeDistance;
00386   float       targetDistance;
00387 };
00388 NVSG_CTASSERT(sizeof(NBFViewState)%4==0);
00389
00391 struct NBFObject
00392 {
00393   uint_t      objectCode;
00394   ubyte_t     isShared;
00395
00396
00397   PADDING(3);
00398   uint64_t    objectDataID;
00399   uint_t      sourceObject;
00400
00401   str_t       objectName;
00402   // NOTE: Because of the uint64_t member objectDataID above, which is 8-byte aligned,
00403   // we need to ensure the size of NBFObject is fixed - that is, independent of whatever
00404   // the compilers actual packing value might be! We achieve this by making the size of
00405   // NBFObject a multiple of 8 bytes (see compile time assert below).
00406   PADDING(4);
00407 };
00408 NVSG_CTASSERT(sizeof(NBFObject)%8==0);
00409
00411
00416 struct NBFTrafoAnimation : public NBFObject
00417 {
00418   uint_t      trafos;
00419
00420
00421   PADDING(4);
00422 };
00423 NVSG_CTASSERT(sizeof(NBFTrafoAnimation)%8==0);
00424
00426
00431 struct NBFVNVectorAnimation : public NBFObject
00432 {
00433   uint_t      numVertices;
00434
00435   uint_t      vertexSets;
00436
00437
00438
00439
00440   uint_t      numNormals;
00441
00442   uint_t      normalSets;
00443
00444
00445
00446
00447
00448 };
00449 NVSG_CTASSERT(sizeof(NBFVNVectorAnimation)%8==0);
00450
00452
00457 struct NBFFramedAnimation
00458 {
00459   uint_t      numFrames;
00460
00461
00462
00463
00464 };
00465 NVSG_CTASSERT(sizeof(NBFFramedAnimation)%4==0);
00466
00468
00470 struct NBFFramedTrafoAnimation : public NBFTrafoAnimation
00471                                , public NBFFramedAnimation
00472 {
00473   PADDING(4);
00474 };
00475 NVSG_CTASSERT(sizeof(NBFFramedTrafoAnimation)%8==0);
00476
00478
00480 struct NBFFramedVNVectorAnimation : public NBFVNVectorAnimation
00481                                   , public NBFFramedAnimation
00482 {
00483   PADDING(4);
00484 };
00485 NVSG_CTASSERT(sizeof(NBFFramedVNVectorAnimation)%8==0);
00486
00488
00493 struct NBFInterpolatedAnimation
00494 {
00495   uint_t      numKeys;
00496   uint_t      keys;
00497
00498 };
00499 NVSG_CTASSERT(sizeof(NBFInterpolatedAnimation)%4==0);
00500
00502
00506 struct NBFInterpolatedTrafoAnimation : public NBFTrafoAnimation
00507                                      , public NBFInterpolatedAnimation
00508 {
00509 };
00510 NVSG_CTASSERT(sizeof(NBFInterpolatedTrafoAnimation)%8==0);
00511
00513
00517 struct NBFInterpolatedVNVectorAnimation : public NBFVNVectorAnimation
00518                                         , public NBFInterpolatedAnimation
00519 {
00520 };
00521 NVSG_CTASSERT(sizeof(NBFInterpolatedVNVectorAnimation)%8==0);
00522
00524
00528 struct NBFCamera : public NBFObject
00529 {
00530   uint_t      numHeadLights;
00531   uint_t      headLights;
00532
00533   float3_t    upVector;
00534   float3_t    position;
00535   float3_t    direction;
00536   float       farDist;
00537   float       nearDist;
00538   float       focusDist;
00539   ubyte_t     isAutoClipPlanes;
00540   PADDING(3);
00541   float2_t    windowSize;
00542
00543   float2_t    windowOffset;
00544
00545   PADDING(4);
00546 };
00547 NVSG_CTASSERT(sizeof(NBFCamera)%8==0);
00548
00550
00552 struct NBFParallelCamera : public NBFCamera
00553 {
00554 };
00555 NVSG_CTASSERT(sizeof(NBFParallelCamera)%8==0);
00556
00558
00560 struct NBFPerspectiveCamera : public NBFCamera
00561 {
00562 };
00563 NVSG_CTASSERT(sizeof(NBFPerspectiveCamera)%8==0);
00564
00566
00570 struct NBFDrawable : public NBFObject
00571 {
00572 };
00573 NVSG_CTASSERT(sizeof(NBFDrawable)%8==0);
00574
00576
00578 struct NBFVertexAttributeSet : public NBFObject
00579 {
00580   uint_t      numVertices;
00581   uint_t      vertices;
00582   uint_t      numNormals;
00583   uint_t      normals;
00584   uint_t      numTexCoordsSets;
00585   uint_t      texCoordsSets;
00586
00587   uint_t      numColors;
00588   uint_t      colorDim;
00589
00590   uint_t      colors;
00591
00592   uint_t      numSecondaryColors;
00593   uint_t      secondaryColorDim;
00594
00595   uint_t      secondaryColors;
00596
00597   uint_t      numFogCoords;
00598   uint_t      fogCoords;
00599
00600 };
00601 NVSG_CTASSERT(sizeof(NBFVertexAttributeSet)%8==0);
00602
00604
00605 struct NBFPrimitiveSet : public NBFDrawable
00606 {
00607   uint_t      vertexAttributeSet;
00608   PADDING(4);
00609 };
00610 NVSG_CTASSERT(sizeof(NBFPrimitiveSet)%8==0);
00611
00613
00615 struct NBFIndependentPrimitiveSet : public NBFPrimitiveSet
00616 {
00617   uint_t      numIndices;
00618   uint_t      indices;
00619 };
00620 NVSG_CTASSERT(sizeof(NBFIndependentPrimitiveSet)%8==0);
00621
00623
00625 struct NBFMeshedPrimitiveSet : public NBFPrimitiveSet
00626 {
00627   uint_t      numMeshes;
00628   uint_t      meshes;
00629
00630 };
00631 NVSG_CTASSERT(sizeof(NBFMeshedPrimitiveSet)%8==0);
00632
00634
00636 struct NBFStrippedPrimitiveSet : public NBFPrimitiveSet
00637 {
00638   uint_t      numStrips;
00639   uint_t      strips;
00640
00641 };
00642 NVSG_CTASSERT(sizeof(NBFStrippedPrimitiveSet)%8==0);
00643
00645
00647 struct NBFAnimatedIndependents : public NBFIndependentPrimitiveSet
00648 {
00649   uint_t      animation;
00650
00651   PADDING(4);
00652 };
00653 NVSG_CTASSERT(sizeof(NBFAnimatedIndependents)%8==0);
00654
00656
00658 struct NBFSkinnedTriangles : public NBFIndependentPrimitiveSet
00659 {
00660   uint_t      numSkins;
00661   uint_t      skins;
00662 };
00663 NVSG_CTASSERT(sizeof(NBFSkinnedTriangles)%8==0);
00664
00666
00670 struct NBFNode : public NBFObject
00671 {
00672   str_t       annotation;         //<! Specifies an optional annotation string.
00673   PADDING(6);
00674   ubyte_t     systemHints;
00675   ubyte_t     userHints;
00676 };
00677 NVSG_CTASSERT(sizeof(NBFNode)%8==0);
00678
00680
00681 struct NBFGeoNode : public NBFNode
00682 {
00683   uint_t      numGeometrySets;    //<! Specifies the number of contained geometry sets.
00684   uint_t      geometrySets;       //<! Specifies the file offset to the geometry sets.
00685                                   //<! Geometry sets are stored as geometrySet_t objects.
00686 };
00687 NVSG_CTASSERT(sizeof(NBFGeoNode)%8==0);
00688
00690
00693 struct NBFGroup : public NBFNode
00694 {
00695   uint_t      numChildren;
00696   uint_t      children;
00697
00698   uint_t      numClipPlanes;
00699   uint_t      clipPlanes;
00700 };
00701 NVSG_CTASSERT(sizeof(NBFGroup)%8==0);
00702
00704
00705 struct NBFLOD : public NBFGroup
00706 {
00707   float3_t    center;
00708   uint_t      numRanges;
00709   uint_t      ranges;
00710
00711   PADDING(4);
00712 };
00713 NVSG_CTASSERT(sizeof(NBFLOD)%8==0);
00714
00716
00717 struct NBFSwitch : public NBFGroup
00718 {
00719   uint_t      numActiveChildren;
00720   uint_t      activeChildren;
00721
00722 };
00723 NVSG_CTASSERT(sizeof(NBFSwitch)%8==0);
00724
00726
00727 struct NBFBillboard: public NBFGroup
00728 {
00729   float3_t  rotationAxis;
00730   ubyte_t   screenAligned;
00731   PADDING(3);
00732 };
00733 NVSG_CTASSERT(sizeof(NBFBillboard)%8==0);
00734
00736
00737 struct NBFTransform : public NBFGroup
00738 {
00739   trafo_t             trafo;
00740   PADDING(4);
00741 };
00742 NVSG_CTASSERT(sizeof(NBFTransform)%8==0);
00743
00745
00746 struct NBFAnimatedTransform : public NBFTransform
00747 {
00748   uint_t      animation;
00749
00750   PADDING(4);
00751 };
00752 NVSG_CTASSERT(sizeof(NBFAnimatedTransform)%8==0);
00753
00755
00757 struct NBFLightSource : public NBFNode
00758 {
00759   float       intensity;
00760   float3_t    ambientColor;
00761   float3_t    diffuseColor;
00762   float3_t    specularColor;
00763   ubyte_t     castShadow;
00764   PADDING(3);
00765   uint_t      animation;
00766
00767 };
00768 NVSG_CTASSERT(sizeof(NBFLightSource)%8==0);
00769
00770 // The NBFDirectedLight structure represents a directed light source.
00772 struct NBFDirectedLight : public NBFLightSource
00773 {
00774   float3_t direction;
00775   PADDING(4);
00776 };
00777 NVSG_CTASSERT(sizeof(NBFDirectedLight)%8==0);
00778
00779 // The NBFPointLight structure represents a point light source.
00781 struct NBFPointLight : public NBFLightSource
00782 {
00783   float3_t position;
00784   float3_t attenuation;
00785
00786
00787
00788 };
00789 NVSG_CTASSERT(sizeof(NBFPointLight)%8==0);
00790
00791 // The NBFSpotLight structure represents a spot light.
00793 struct NBFSpotLight : public NBFLightSource
00794 {
00795   float3_t position;
00796   float3_t direction;
00797   float3_t attenuation;
00798
00799
00800
00801   float    cutoffAngle;
00802
00803   float    falloffExponent;
00804   PADDING(4);
00805 };
00806 NVSG_CTASSERT(sizeof(NBFSpotLight)%8==0);
00807
00809
00810 struct NBFStateSet : public NBFObject
00811 {
00812   uint_t activeKey;
00813   uint_t numStateVariants;
00814   uint_t keyStateVariantPairs;
00815   PADDING(4);
00816 };
00817 NVSG_CTASSERT(sizeof(NBFStateSet)%8==0);
00818
00820
00821 struct NBFStateVariant : public NBFObject
00822 {
00823   uint_t      numStatePasses;
00824   uint_t      statePasses;
00825 };
00826 NVSG_CTASSERT(sizeof(NBFStateVariant)%8==0);
00827
00829
00830 struct NBFStatePass : public NBFObject
00831 {
00832   uint_t      numStateAttribs;
00833   uint_t      stateAttribs;
00834 };
00835 NVSG_CTASSERT(sizeof(NBFStatePass)%8==0);
00836
00838
00840 struct NBFStateAttribute : public NBFObject
00841 {
00842 };
00843 NVSG_CTASSERT(sizeof(NBFStateAttribute)%8==0);
00844
00846
00847 struct NBFBlendAttribute : public NBFStateAttribute
00848 {
00849   ubyte_t     sourceFunction;
00850   ubyte_t     destinationFunction;
00851   PADDING(6);
00852 };
00853 NVSG_CTASSERT(sizeof(NBFBlendAttribute)%8==0);
00854
00856
00857 struct NBFCgFx : public NBFStateAttribute
00858 {
00859   PADDING(3);
00860   ubyte_t     fromFile;
00862   str_t       source;
00863   uint_t      numTweaks;
00864   uint_t      tweaks;
00866   uint_t      numSamplers;
00867   uint_t      samplers;
00869   str_t       currTech;
00870   PADDING(4);
00871 };
00872 NVSG_CTASSERT(sizeof(NBFCgFx)%8==0);
00873
00875
00876 struct NBFDepthAttribute : public NBFStateAttribute
00877 {
00878   ubyte_t     depthFunction;
00879   ubyte_t     depthTestingEnabled;
00880   ubyte_t     depthWritingEnabled;
00881   PADDING(5);
00882 };
00883 NVSG_CTASSERT(sizeof(NBFDepthAttribute)%8==0);
00884
00886
00887 struct NBFFaceAttribute : public NBFStateAttribute
00888 {
00889   ubyte_t     cullMode;
00890   ubyte_t     polygonOffsetEnabled;
00891   PADDING(2);
00892   float       polygonOffsetFactor;
00893
00894   float       polygonOffsetUnits;
00895
00896   ubyte_t     twoSidedLighting;
00897   ubyte_t     frontFaceMode;
00898   ubyte_t     backFaceMode;
00899   PADDING(1);
00900 };
00901 NVSG_CTASSERT(sizeof(NBFFaceAttribute)%8==0);
00902
00904
00905 struct NBFLineAttribute : public NBFStateAttribute
00906 {
00907   ubyte_t     antiAliasing;
00908   PADDING(3);
00909   uint_t      stippleFactor;
00910   uint_t      stipplePattern;
00911   float       width;
00912 };
00913 NVSG_CTASSERT(sizeof(NBFLineAttribute)%8==0);
00914
00916
00917 struct NBFMaterial : public NBFStateAttribute
00918 {
00919   float3_t    frontAmbientColor;
00920   float3_t    frontDiffuseColor;
00921   float3_t    frontEmissiveColor;
00922   float       frontOpacity;
00923   float3_t    frontSpecularColor;
00924   float       frontSpecularExponent;
00925   float3_t    backAmbientColor;
00926   float3_t    backDiffuseColor;
00927   float3_t    backEmissiveColor;
00928   float       backOpacity;
00929   float3_t    backSpecularColor;
00930   float       backSpecularExponent;
00931 };
00932 NVSG_CTASSERT(sizeof(NBFMaterial)%8==0);
00933
00935
00936 struct NBFPointAttribute : public NBFStateAttribute
00937 {
00938   ubyte_t     antiAliasing;
00939   PADDING(3);
00940   float       size;
00941 };
00942 NVSG_CTASSERT(sizeof(NBFPointAttribute)%8==0);
00943
00945
00946 struct NBFTextureAttribute : public NBFStateAttribute
00947 {
00948   uint_t      numBindings;
00949   uint_t      bindings;
00950
00951 };
00952 NVSG_CTASSERT(sizeof(NBFTextureAttribute)%8==0);
00953
00955
00958 struct NBFTextureAttributeItem : public NBFObject
00959 {
00960   uint_t        texImg;
00961   float4_t      texEnvColor;
00962   uint_t        texEnvMode;
00963
00964   uint_t        texWrapS;
00965
00966   uint_t        texWrapT;
00967
00968   uint_t        texWrapR;
00969
00970   uint_t        minFilter;
00971
00972   uint_t        magFilter;
00973
00974   float4_t      texBorderColor;
00975   trafo_t       trafo;
00976   uint_t        texGenMode[4];
00977   float4_t      texGenPlane[2][4];
00978 };
00979 NVSG_CTASSERT(sizeof(NBFTextureAttributeItem)%8==0);
00980
00981 #pragma pack(pop)
00982
00983 #undef __NVSG_CTASSERT_PREFIX
Generated on Fri Aug 4 08:33:05 2006 for NVSGSDK by NVIDIA


Node.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.h"
#include "nvmath/Sphere3f.h"
#include "nvutil/BitMask.h"
#include "nvutil/Lockable.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 Fri Aug 4 08:34:34 2006 for NVSGSDK by NVIDIA


Node.h Source File

Node.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 #include "nvmath/Sphere3f.h"
00018 #include "nvutil/BitMask.h"
00019 #include "nvutil/Lockable.h"
00020 #include <vector>
00021
00022 namespace nvsg
00023 {
00024 class Group;
00025
00029 class Node : public Object
00030 {
00031   public:
00062     enum NodeHints
00063     {
00064       NH_CULL_MASK              = BIT0 | BIT1,
00065       NH_CULL_NEVER             = BIT0,
00066       NH_CULL_ALWAYS            = BIT1,
00067
00068       NH_NO_SHADOW_CASTER       = BIT2,
00069       NH_NO_SHADOW_RECEIVER     = BIT3,
00070
00071       NH_OVERLAY                = BIT4,
00072
00073       NH_MODIFY_FREQUENCY_MASK  = BIT5 | BIT6,
00074       NH_MODIFY_FREQUENCY_LOW   = BIT5,
00075       NH_MODIFY_FREQUENCY_HIGH  = BIT6,
00076
00077       NH_RESERVED_BITS          = 0x80,
00078       NH_CUSTOM_BITS            = 0xFF00,
00079     };
00080
00081   public:
00094     NVSG_API virtual const Node * clone() const = 0;
00095
00098     NVSG_API size_t getNumberOfParents() const;
00099
00112     NVSG_API const Group * getParent(size_t index) const;
00113
00123     NVSG_API const nvmath::Sphere3f & getBoundingSphere() const;
00124
00131     NVSG_API void invalidateBoundingSphere();
00132
00145     NVSG_API bool containsTransparentGeometry() const;
00146
00153     NVSG_API void invalidateTransparencyContainment();
00154
00167     NVSG_API virtual bool containsCgFx() const;
00168
00175     NVSG_API virtual void invalidateCgFxContainment();
00176
00189     NVSG_API virtual bool containsLight() const;
00190
00197     NVSG_API virtual void invalidateLightContainment();
00198
00213     NVSG_API virtual size_t getNumberOfFrames() const;
00214
00221     NVSG_API virtual void invalidateNumberOfFrames() const;
00222
00230     NVSG_API void setAnnotation(const std::string& anno);
00231
00239     NVSG_API const std::string& getAnnotation() const;
00240
00246     NVSG_API unsigned short getHints( unsigned short mask = 0xFFFF ) const;
00247
00251     NVSG_API void setHints( unsigned short hints );
00252
00258     NVSG_API void addHints( unsigned short hints );
00259
00265     NVSG_API void removeHints( unsigned short hints );
00266
00275     NVSG_API bool containsHints( unsigned short hints ) const;
00276
00283     NVSG_API void invalidateHintsContainment( unsigned short hints );
00284
00285   #if !defined( NDEBUG )
00286
00290     NVSG_API void assertInvalidBoundingSphere() const;
00291   #endif
00292
00293   protected:
00298     NVSG_API Node(void);
00299
00304     NVSG_API Node(const Node& rhs);
00305
00310     NVSG_API virtual ~Node(void);
00311
00321     NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const = 0;
00322
00329     NVSG_API virtual unsigned short determineHintsContainment( unsigned short hints ) const;
00330
00341     NVSG_API virtual bool determineTransparencyContainment() const = 0;
00342
00352     NVSG_API Node & operator=(const Node & rhs);
00353
00359     NVSG_API virtual void invalidateIncarnation();
00360
00361   private:
00362     // helpers with managing parent/child relationships
00363     friend class Group; // Group needs access to these helpers - no one else!
00364     void addParent(const Group * group);
00365     void removeParent(const Group * group);
00366
00367   private:
00368     std::string                                         * m_annotation;
00369     unsigned short                                        m_hints;
00370     bool                                                  m_inOverlay;
00371     std::vector< nvutil::PointerReference<const Group> >  m_parents;
00372
00373     mutable nvmath::Sphere3f  m_boundingSphere;
00374     mutable bool              m_boundingSphereValid;
00375     mutable unsigned short    m_hintsContainment;
00376     mutable unsigned short    m_hintsContainmentValid;
00377     mutable bool              m_transparencyContainment;
00378     mutable bool              m_transparencyContainmentValid;
00379 };
00380
00381 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
00382
00383 inline size_t Node::getNumberOfParents() const
00384 {
00385   return m_parents.size();
00386 }
00387
00388 inline const Group * Node::getParent( size_t i ) const
00389 {
00390   NVSG_ASSERT(i < m_parents.size()); // undefined behavior for invalid index!
00391   return m_parents[i];
00392 }
00393
00394 inline unsigned short Node::getHints( unsigned short mask ) const
00395 {
00396   return( m_hints & mask );
00397 }
00398
00399 inline void Node::setHints( unsigned short hints )
00400 {
00401   m_hints = hints;
00402 }
00403
00404 inline void Node::addHints( unsigned short hints )
00405 {
00406   m_hints |= hints;
00407 }
00408
00409 inline void Node::removeHints( unsigned short hints )
00410 {
00411   m_hints &= ~hints;
00412 }
00413
00414 } // namespace
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:35 2006 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 Traverser
00024   {
00025     public:
00027       NVSG_API NormalizeTraverser(void);
00028
00030
00031       NVSG_API size_t getVertexAttributeIndex() const;
00032
00034
00035       NVSG_API void setVertexAttributeIndex( size_t attrib );
00036
00037     protected:
00039       NVSG_API virtual ~NormalizeTraverser(void);
00040
00042       NVSG_API virtual void  doApply( const nvsg::Scene * scene );
00043
00045       void  handleVertexAttributeSet( const nvsg::VertexAttributeSet * p );
00046
00047     private:
00048       template<unsigned char dim>
00049         void  normalizeData( const nvsg::VertexAttributeSet * p );
00050
00051     private:
00052       size_t                                      m_attrib;
00053       std::set<const nvsg::VertexAttributeSet *>  m_multiOwnedVAS;
00054   };
00055
00056   inline size_t NormalizeTraverser::getVertexAttributeIndex() const
00057   {
00058     return( m_attrib );
00059   }
00060
00061   inline void NormalizeTraverser::setVertexAttributeIndex( size_t attrib )
00062   {
00063     m_attrib = attrib;
00064   }
00065 }
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:36 2006 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     const nvsg::Scene * load( const std::string& filename
00069                             , const std::vector<std::string> &searchPaths
00070                             , const nvsg::ViewState *& 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 }
00105
00106 inline const nvsg::Scene * NVBLoader::load( const std::string& filename, const std::vector<std::string> &searchPaths, const nvsg::ViewState *& viewState )
00107 {
00108   NVSG_TRACE();
00109   const nvsg::Scene * scene = NULL;
00110   std::string theFile = filename;
00111   if ( nvutil::FindFileFirst(filename, searchPaths, theFile) )
00112   {
00113     FILE  * fh = fopen( theFile.c_str(), "rb" );
00114     char  header[5];
00115     fread( header, 1, 4, fh );
00116     header[4] = '\0';
00117     fclose( fh );
00118
00119     if ( !strcmp( header, "NVBP" ) || !strcmp( header, "NVB!" ) )
00120     {
00121       if ( ! m_nvnvb )
00122       {
00123         m_nvnvb = new NVNVB;
00124         NVSG_ASSERT( m_nvnvb );
00125       }
00126       scene = m_nvnvb->load( theFile, searchPaths, viewState );
00127     }
00128     else if ( !strcmp( header, "NVB2" ) )
00129     {
00130       if ( ! m_nvnvb2 )
00131       {
00132         m_nvnvb2 = new NVNVB2;
00133         NVSG_ASSERT( m_nvnvb2 );
00134       }
00135       scene = m_nvnvb2->load( theFile, searchPaths, viewState );
00136     }
00137     else
00138     {
00139       NVSG_TRACE_OUT_F(("Invalid file format: %s !\n", header ));
00140       scene = NULL;
00141     }
00142   }
00143   else
00144   {
00145     NVSG_TRACE_OUT_F(("File %s not found!\n", filename.c_str()))
00146   }
00147   return( scene );
00148 }
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


NVBLoadTraverser.h File Reference

#include "nvmath/Vec2f.h"
#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 Fri Aug 4 08:34:37 2006 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  "nvmath/Vec2f.h"
00016 #include  "nvtraverser/Traverser.h"
00017
00019 class NVBLoadTraverser : public nvtraverser::Traverser
00020 {
00021   public:
00023     NVBLoadTraverser( std::vector<const nvsg::Material *> &faceMappedMaterials );
00024
00026     virtual ~NVBLoadTraverser(void);
00027
00028   protected:
00030
00031     virtual void  handleCgFx( const nvsg::CgFx *p );
00032
00034
00035     virtual void  handleGeoNode( const nvsg::GeoNode *p );
00036
00038     virtual void  handleLOD( const nvsg::LOD *p )                                { NVSG_ASSERT( false ); }
00039
00041
00042     virtual void  handleMaterial( const nvsg::Material *p, bool reset );
00043
00045
00046     virtual void  handleStateSet( const nvsg::StateSet *p );
00047
00049     virtual void  handleSwitch( const nvsg::Switch *p )                          { NVSG_ASSERT( false ); }
00050
00052
00054     virtual void  handleTriangles( const nvsg::Triangles *p );
00055
00056   private:
00057     bool                  m_bApplyingCgFx;
00058     const nvsg::Material            * m_currentMaterial;
00059     std::vector<const nvsg::Material *>  * m_faceMappedMaterials;
00060     std::vector<nvmath::Vec2f>         m_texCoords;
00061 };
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


nvmath.h File Reference

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

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 Fri Aug 4 08:34:38 2006 for NVSGSDK by NVIDIA


nvmath.h Source File

nvmath.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  <algorithm> // for std::max, std::min (_MAX, _MIN)
00018 #include  <float.h>
00019
00021 namespace nvmath
00022 {
00023   // define the stand trig values
00024 #ifdef PI
00025 # undef PI
00026 # undef PI_HALF
00027 # undef PI_QUARTER
00028 #endif
00029
00030   const float PI            = 3.14159265358979323846f;
00032   const float PI_HALF       = 1.57079632679489661923f;
00034   const float PI_QUARTER    = 0.78539816339744830962f;
00036   const float SQRT_TWO      = 1.41421356237309504880f;
00038   const float SQRT_TWO_HALF = 0.70710678118654752440f;
00039
00041
00042   template<class T> T     clamp( T v
00043                                , T l
00044                                , T u
00045                                )
00046   {
00047     return std::min(u, std::max(l,v));
00048   }
00049
00051
00052   inline  float degToRad( float angle
00053                         )
00054   {
00055     return( angle*PI/180.0f );
00056   }
00057
00059
00060   inline  bool  isPowerOfTwo( int n
00061                             )
00062   {
00063     return( n == ( n & -n ) );
00064   }
00065
00067
00068   template<typename T> T lerp( float alpha
00069                              , const T &v0
00070                              , const T &v1
00071                              )
00072   {
00073     return( v0 + alpha * ( v1 - v0 ) );
00074   }
00075
00077
00078   inline size_t  powerOfTwoBelow( size_t n
00079                                 )
00080   {
00081     size_t h2 = 1;
00082     for ( size_t h = n ; h ; h>>=1, h2<<=1 )
00083       ;
00084     return( h2 >> 1 );
00085   }
00086
00088
00089   inline float radToDeg( float angle
00090                        )
00091   {
00092     return( angle*180.0f/PI );
00093   }
00094
00096
00097   template<typename T> int sign( const T &t
00098                                )
00099   {
00100     return( ( t < 0 ) ? -1 : ( ( t > 0 ) ? 1 : 0 ) );
00101   }
00102
00104
00105   template<typename T> float square( const T& t
00106                                    )
00107   {
00108     return( t * t );
00109   }
00110
00111 }
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


NVNVB.h File Reference

#include <set>
#include "nvsg/nvsgapi.h"
#include "nvmath/Vec2f.h"
#include "nvsg/Face.h"
#include "nvsg/Scene.h"
#include "nvsg/SkinnedTriangles.h"
#include "nvsg/TextureAttribute.h"
#include "nvsg/ViewState.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.

Namespaces

namespace | nvsg

Classes

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

struct | NVNVB::SkinnedTrianglesInfo

Detailed Description

Generated on Fri Aug 4 08:34:39 2006 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
00014 #include <set>
00015 #include "nvsg/nvsgapi.h"
00016 #include "nvmath/Vec2f.h"
00017 #include "nvsg/Face.h"
00018 #include "nvsg/Scene.h"
00019 #include "nvsg/SkinnedTriangles.h"
00020 #include "nvsg/TextureAttribute.h"
00021 #include "nvsg/ViewState.h"
00022 #include "NVBBreaker/inc/NVBLoader.h"
00023
00024 // forward declarations
00025 namespace nvsg
00026 {
00027   class AnimatedTransform;
00028   class Camera;
00029   class FaceAttribute;
00030   class LightSource;
00031   class Material;
00032   class Scene;
00033   class StateSet;
00034   class Transform;
00035 }
00036
00037 //  it's not neccessary to document this helper class !
00038 #if ! defined( DOXYGEN_IGNORE )
00039 class MeshData
00040 {
00041   public:
00042     MeshData();
00043
00044   public:
00045     std::vector<std::vector<sdword> > m_animationIDs;
00046     std::vector<std::vector<nvmath::Vec3f> >  m_boneOffsets;
00047     unsigned int            m_faceCount;
00048     std::vector<nvsg::Face3>           m_faces;
00049     std::vector<size_t>          m_normalIndices;
00050     std::vector<nvmath::Vec3f>           m_normals;
00051     unsigned int            m_matId;
00052     std::vector<nvsg::Skin>            m_skins;
00053     std::vector<nvmath::Vec3f>           m_vertices;
00054     std::vector<std::vector<nvmath::Vec2f> >  m_texCoords;
00055     unsigned int            m_vertexCount;
00056 };
00057
00058 inline MeshData::MeshData()
00059 : m_faceCount( 0 )
00060 {
00061 }
00062 #endif  //  DOXYGEN_IGNORE
00063
00065 class NVNVB : public NVBRenderManager::NVBBreaker
00066 {
00067   public:
00068     NVNVB(void);
00069     ~NVNVB(void);
00070
00071   public:
00073
00074     const nvsg::Scene * load( const std::string& filename
00075                             , const std::vector<std::string> &searchPaths
00076                             , const nvsg::ViewState *& viewState
00077                             );
00078
00079     // Application-dependent import methods, called by the importer
00081     virtual bool  NewScene      ( const NVBRenderManager::NVBSceneInfo& scene );
00083     virtual bool  NewCamera     ( const NVBRenderManager::NVBCameraInfo& camera );
00085     virtual bool  NewLight      ( const NVBRenderManager::NVBLightInfo& light );
00087     virtual bool  NewMaterial   ( const NVBRenderManager::NVBMaterialInfo& material );
00089     virtual bool  NewTexture    ( const NVBRenderManager::NVBTextureInfo& texture );
00091     virtual bool  NewMesh       ( const NVBRenderManager::NVBMeshInfo& mesh );
00093     virtual bool  NewShape      ( const NVBRenderManager::NVBShapeInfo& shape );
00095     virtual bool  NewHelper     ( const NVBRenderManager::NVBHelperInfo& helper );
00097     virtual bool  NewController ( const NVBRenderManager::NVBControllerInfo& controller );
00099     virtual bool  NewMotion     ( const NVBRenderManager::NVBMotionInfo& motion );
00100
00102     virtual bool  EndImport     ( void );
00103
00105     virtual bool  NVBImportError  ( const char* errortext, udword errorcode );
00106
00108     virtual void  NVBLog          ( NVBRenderManager::TLogLevel level, LPSTR fmt, ... );
00110     virtual void  SetLogCallback  ( NVBRenderManager::TloggingCB cbfn, unsigned long userparam = 0 );
00111
00112   private:
00113     void        addMap( sdword mapID, float coeff, const nvsg::TextureAttribute * texAttrib, size_t& unit );
00114     void        addMaps( const NVBRenderManager::NVBMaterialInfo& material, nvsg::Material *pMaterial );
00115     const nvsg::Transform * newTransform( sdword ID, const Point &pos, const Quat &rot, size_t position = 0xFFFFFFFF );
00116
00117   private:
00118     std::map<const nvsg::Camera *, sdword>                m_cameraToTransformID;
00119     std::vector<const nvsg::Material *>                   m_faceMappedMaterial;
00120     std::set<sdword>                                      m_invalidTextureIDs;
00121     std::map<sdword, const nvsg::AnimatedTransform *>     m_IDToAnimatedTransform;
00122     std::map<sdword, const nvsg::Material *>              m_IDToMaterial;
00123     std::map<sdword, std::string>                         m_IDToTextureFileName;
00124     std::map<sdword, nvmath::Quatf>                       m_IDToTextureOrientation;
00125     std::map<sdword, nvmath::Vec3f>                       m_IDToTextureScaling;
00126     std::map<sdword, nvmath::Vec3f>                       m_IDToTextureTranslation;
00127     std::map<sdword, nvsg::Transform *>                   m_IDToTransform;
00128     std::map<const nvsg::LightSource *, sdword>           m_lightToTransformID;
00129     std::set<std::string>                                 m_materialNames;
00130     std::map<const nvsg::Material *, const nvsg::StateSet *>    m_materialToStateSet;
00131     std::vector<MeshData>                                 m_meshData;
00132     int                                                   m_numCgFxAttribs;
00133     const nvsg::Group                                   * m_rootNode;
00134     const nvsg::Scene                                   * m_scene;
00135     std::vector<std::string>                              m_searchPaths;
00136     const nvsg::ViewState                               * m_viewState;
00137
00138     //  On each meshID (sdword) with SkinnedTriangles store some SkinnedTriangles information and the mesh size
00139     //    (number of vertices)
00140     //  The SkinnedTriangles information contains a pair of a pointer to a SkinnedTriangles and pair of a vector of indices
00141     //    into a (mesh-)common normal array and a vector of ids of (Animated)Transforms.
00142     //  For each material in this mesh, there is one such pair (of a pointer and a pair).
00143     typedef struct
00144     {
00145       std::vector<std::vector<sdword> >         m_animationIDs;
00146       std::vector<std::vector<nvmath::Vec3f> >  m_boneOffsets;
00147       std::vector<size_t>                       m_normalIndices;
00148     } SkinnedTrianglesInfo;
00149     std::map<sdword,std::pair<std::vector<std::pair<nvsg::SkinnedTriangles*,SkinnedTrianglesInfo> >,size_t> > m_IDToSkinnedTriangles;
00150
00151 #if !defined(NDEBUG)
00152     std::set<udword> m_meshIds;
00153 #endif
00154 };
00155
00156 inline const nvsg::Scene * NVNVB::load( const std::string& filename, const std::vector<std::string> &searchPaths
00157                                       , const nvsg::ViewState *& viewState )
00158 {
00159   NVSG_TRACE();
00160
00161   if ( m_scene )
00162   {
00163     m_scene->removeRef();
00164   }
00165   m_scene = NULL;
00166   if ( m_viewState )
00167   {
00168     m_viewState->removeRef();
00169   }
00170   m_viewState = NULL;
00171
00172   // We need to clean up everything, so we can use loader instance more than once.
00173   m_cameraToTransformID.clear();
00174   m_faceMappedMaterial.clear();
00175   m_invalidTextureIDs.clear();
00176   m_IDToAnimatedTransform.clear();
00177   m_IDToMaterial.clear();
00178   m_IDToTextureFileName.clear();
00179   m_IDToTextureOrientation.clear();
00180   m_IDToTextureScaling.clear();
00181   m_IDToTextureTranslation.clear();
00182   m_IDToTransform.clear();
00183   m_lightToTransformID.clear();
00184   m_materialNames.clear();
00185   m_materialToStateSet.clear();
00186   m_meshData.clear();
00187   m_numCgFxAttribs=0;
00188   m_rootNode=NULL;
00189   m_IDToSkinnedTriangles.clear();
00190
00191 #if !defined(NDEBUG)
00192   m_meshIds.clear();
00193 #endif
00194
00195   // private copy of the search paths
00196   m_searchPaths = searchPaths;
00197
00198   // run the importer
00199   if ( !Import( filename.c_str() ) )
00200   {
00201     NVSG_TRACE_OUT_F(("Failed to import %s!\n", filename.c_str()))
00202   }
00203   NVSG_ASSERT(m_scene);
00204   viewState = m_viewState;
00205   return( m_scene );
00206 }
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


NVNVB2.h File Reference

#include <map>
#include "nvsg/nvsgapi.h"
#include "nvmath/Mat44f.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.

Namespaces

namespace nvsg

Detailed Description

Generated on Fri Aug 4 08:34:40 2006 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  "nvmath/Mat44f.h"
00017
00018 namespace nvsg
00019 {
00020   class GeoNode;
00021   class Scene;
00022   class StateSet;
00023   class TextureAttributeItem;
00024   class Transform;
00025   class ViewState;
00026 }
00027
00028
00029 //  it's not necessary to document all these helper classes !
00030 #if ! defined( DOXYGEN_IGNORE )
00031
00032 class NVB2Animation
00033 {
00034   public:
00035     float         frequency;
00036     std::vector<nvmath::Quatf> rotations;
00037     std::vector<nvmath::Vec3f> positions;
00038     std::vector<nvmath::Vec3f> scales;
00039 };
00040
00041 class NVB2Attribute
00042 {
00043   public:
00044     ~NVB2Attribute();
00045
00046   public:
00047     std::map<std::string,NVB2Attribute*> entries;
00048     unsigned int                    arraySize;
00049     unsigned int                    arrayType;
00050     std::vector<char>                    array;
00051     unsigned int                    udWord;
00052 };
00053
00054 class NVB2Material
00055 {
00056   public:
00057     std::string               name;
00058     std::vector<unsigned int> textureIdxs;
00059     std::vector<unsigned int> textureChannels;
00060     nvmath::Vec4f             diffuse;
00061     nvmath::Vec4f             specular;
00062     float                     shininess;
00063     nvmath::Vec4f             ambient;
00064     nvmath::Vec4f             emission;
00065     float                     transparency;
00066     bool                      fog;
00067     nvmath::Vec4f             fogColor;
00068     NVB2Attribute             attribute;
00069
00070     const nvsg::StateSet    * stateSet;
00071 };
00072
00073 class NVB2TexCoordSet
00074 {
00075   public:
00076     unsigned int  texDim;
00077     std::vector<float> texCoords;
00078     std::vector<nvmath::Vec3f> binormals;
00079     std::vector<nvmath::Vec3f> tangents;
00080 };
00081
00082 class NVB2Mesh
00083 {
00084   public:
00085     unsigned int            materialID;
00086     std::vector<nvmath::Vec3f>           vertices;
00087     std::vector<nvmath::Vec3f>           normals;
00088     std::vector<nvmath::Vec4f>           colors;
00089     std::vector<nvmath::Vec4f>           weights;
00090     std::vector<unsigned int>    boneIdxs;
00091     std::vector<NVB2TexCoordSet> texCoordSets;
00092     std::vector<unsigned int>    faceIdxs;
00093     NVB2Attribute           attribute;
00094     nvmath::Vec3f                   aabbMin;
00095     nvmath::Vec3f                   aabbMax;
00096 };
00097
00098 class NVB2Texture
00099 {
00100   public:
00101     unsigned int            texType;
00102     std::string                  fileName;
00103     nvmath::Mat44f                  xform;
00104     const nvsg::TextureAttributeItem  * textureAttributeItem;
00105 };
00106
00107 class NVB2Node
00108 {
00109   public:
00110     NVB2Node();
00111     virtual ~NVB2Node();
00112
00113   public:
00114     std::string                  name;
00115     nvmath::Mat44f                  xform;
00116     std::vector<unsigned int>    children;
00117     unsigned int            parent;
00118     unsigned int            target;
00119     NVB2Animation           animation;
00120     NVB2Attribute           attribute;
00121
00122     nvmath::Quatf                   orientation;
00123     nvmath::Vec3f                   position;
00124     const nvsg::Transform             * transform;
00125 };
00126
00127 class NVB2Camera : public NVB2Node
00128 {
00129   public:
00130     float fieldOfView;
00131     float focalLength;
00132 };
00133
00134 class NVB2Light : public NVB2Node
00135 {
00136   public:
00137     nvmath::Vec4f         color;
00138     nvmath::Vec4f         specular;
00139     nvmath::Vec4f         ambient;
00140     unsigned int  lightType;
00141     float         specularExp;
00142     nvmath::Vec3f         direction;
00143     float         range;
00144     float         attConst;
00145     float         attLinear;
00146     float         attQuadratic;
00147     float         falloff;
00148     float         theta;
00149     float         phi;
00150 };
00151
00152 class NVB2Model : public NVB2Node
00153 {
00154   public:
00155     std::vector<NVB2Mesh>  meshes;
00156     nvmath::Vec3f          aabbMin;
00157     nvmath::Vec3f          aabbMax;
00158 };
00159
00160 class NVNVB2
00161 {
00162   public:
00163     NVNVB2();
00164
00165   public:
00166     const nvsg::Scene * load( const std::string& filename, const std::vector<std::string> &searchPaths
00167                             , const nvsg::ViewState *& viewState );
00168
00169   private:
00170     void          interpretAttribute( NVB2Attribute &attribute );
00171     void          interpretCamera( NVB2Camera *camera );
00172     void          interpretLight( NVB2Light *light );
00173     void          interpretMaterials( void );
00174     void          interpretMesh( NVB2Mesh &mesh, nvsg::GeoNode *geoNode );
00175     void          interpretModel( NVB2Model *node );
00176     void          interpretNode( NVB2Node *node );
00177     void          interpretNodes( void );
00178     void          interpretTextures( void );
00179     void          interpretTransform( NVB2Node *node );
00180     void          loadAnimation( NVB2Animation &animation );
00181     void          loadAttribute( NVB2Attribute &attribute );
00182     void          loadCamera( NVB2Camera *camera );
00183     void          loadLight( NVB2Light *light );
00184     unsigned int  loadMaterial( NVB2Material &material );
00185     void          loadMesh( NVB2Mesh &mesh );
00186     void          loadModel( NVB2Model *node );
00187     void          loadNode( NVB2Node *node );
00188     void          loadScene( void );
00189     void          loadTexCoordSet( NVB2TexCoordSet &texCoordSet );
00190     void          loadTexture( NVB2Texture &texture );
00191
00192   private:
00193     FILE                        * m_fh;
00194     std::vector<NVB2Node*>        m_nodes;
00195     std::vector<NVB2Material>     m_materials;
00196     const nvsg::Scene           * m_scene;
00197     std::vector<std::string>      m_searchPaths;
00198     std::vector<NVB2Texture>      m_textures;
00199     const nvsg::ViewState       * m_viewState;
00200 };
00201
00202 typedef enum
00203 {
00204     LT_ANONYMOUS,
00205     LT_POINT,
00206     LT_DIRECTIONAL,
00207     LT_SPOT
00208 } NVB2LightType;
00209
00210 typedef enum
00211 {
00212     NT_ANONYMOUS       = 0x00000000,
00213     NT_GEOMETRY        = 0x00000001,
00214     NT_LIGHT           = 0x00000002,
00215     NT_CAMERA          = 0x00000003
00216 } NVB2NodeType;
00217
00218 typedef enum
00219 {
00220     NVB2TT_CUSTOM              = 0x00000000,
00221     NVB2TT_AMBIENT             = 0x00000001,
00222     NVB2TT_DIFFUSE             = 0x00000002,
00223     NVB2TT_SPECULAR            = 0x00000003, // specular color map
00224     NVB2TT_SPECULAR_POWER      = 0x00000004, // specular highlight map
00225     NVB2TT_GLOSS               = 0x00000005,
00226     NVB2TT_SELF_ILLUMATION     = 0x00000006,
00227     NVB2TT_BUMP                = 0x00000007,
00228     NVB2TT_NORMAL              = 0x00000008,
00229     NVB2TT_OPACITY             = 0x00000009,
00230     NVB2TT_REFLECTION          = 0x0000000A,
00231     NVB2TT_REFRACTION          = 0x0000000B,
00232     NVB2TT_CUBE_MAP            = 0x0000000C
00233 } NVB2TexType;
00234
00235 enum
00236 {
00237     NV_FLOAT                = 0x00000001,
00238     NV_CHAR                 = 0x00000002,
00239     NV_UNSIGNED_CHAR        = 0x00000004,
00240     NV_UNSIGNED_INT         = 0x00000008,
00241     NV_INT                  = 0x00000010,
00242     NV_SHORT                = 0x00000040,
00243
00244     NV_ARRAY                = 0x00010000,
00245     NV_FLOAT_ARRAY          = 0x00010001,
00246     NV_CHAR_ARRAY           = 0x00010002,
00247     NV_UNSIGNED_CHAR_ARRAY  = 0x00010004,
00248     NV_UNSIGNED_INT_ARRAY   = 0x00010008,
00249     NV_INT_ARRAY            = 0x00010010,
00250     NV_ATTRIBUTE_ARRAY      = 0x00010020,
00251     NV_SHORT_ARRAY          = 0x00010040,
00252     NV_STRING               = 0x00010002,
00253
00254     NV_UNASSIGNED           = 0xFFFFFFFF
00255 };
00256
00257 #endif  //  DOXYGEN_IGNORE
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


nvsg.h File Reference

#include "nvsgcommon.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))

Detailed Description

Generated on Fri Aug 4 08:34:42 2006 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
00017 #include <string>
00018 #include <vector>
00019
00020 #if defined(LINUX)
00021 // Linux specific library entry point
00022 void nvsgLibInit() __attribute__((constructor));
00023 #endif
00024
00026
00028 namespace nvsg
00029 {
00031
00044   NVSG_API void nvsgInitialize(
00045     bool runInMultithreadedEnvironment = false
00048   );
00049
00051
00055   NVSG_API void nvsgTerminate();
00056
00058   NVSG_API void getVersionString(
00059     std::string & string
00060   );
00061
00063   NVSG_API void getSDKName(
00064     std::string & string
00065   );
00066
00068   NVSG_API void getCopyrightString(
00069     std::string & string
00070   );
00071
00073   NVSG_API void getVendorName(
00074     std::string & string
00075   );
00076
00078   typedef std::vector<unsigned int> IndexSet;
00079
00080   class IndexMesh : public IndexSet
00081   {
00082     public:
00083       IndexMesh( void );
00084       IndexMesh( unsigned int width, unsigned int height );
00085       unsigned int getWidth( void ) const;
00086       unsigned int getHeight( void ) const;
00087       void setDimensions( unsigned int width, unsigned int height );
00088
00089     private :
00090       unsigned int  m_width;
00091       unsigned int  m_height;
00092   };
00093
00094   inline IndexMesh::IndexMesh( void )
00095     : m_width(0)
00096     , m_height(0)
00097   {
00098   }
00099
00100   inline IndexMesh::IndexMesh( unsigned int width, unsigned int height )
00101     : std::vector<unsigned int>(width*height)
00102     , m_width(width)
00103     , m_height(height)
00104   {
00105   }
00106
00107   inline unsigned int IndexMesh::getWidth( void ) const
00108   {
00109     return( m_width );
00110   }
00111
00112   inline void IndexMesh::setDimensions( unsigned int width, unsigned int height )
00113   {
00114     m_width = width;
00115     m_height = height;
00116     resize( m_width * m_height );
00117   }
00118
00119   inline unsigned int IndexMesh::getHeight( void ) const
00120   {
00121     return( m_height );
00122   }
00123 }
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:42 2006 for NVSGSDK by NVIDIA


NVSGLoader.h File Reference

#include <fstream>
#include "nvsg/nvsgapi.h"
#include "nvsg/nvsg.h"
#include "nvsg/PlugInterface.h"
#include "nvsg/SkinnedTriangles.h"
#include "nvsg/TextureAttribute.h"

Include dependency graph for NVSGLoader.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg

Classes

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

Functions

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 Fri Aug 4 08:34:42 2006 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/nvsg.h"
00018 #include  "nvsg/PlugInterface.h"
00019 #include  "nvsg/SkinnedTriangles.h"
00020 #include  "nvsg/TextureAttribute.h"
00021
00022 // forward declarations
00023 namespace nvsg
00024 {
00025   class AnimatedQuads;
00026   class AnimatedTransform;
00027   class AnimatedTriangles;
00028   class Billboard;
00029   class BlendAttribute;
00030   class Camera;
00031   class CgFx;
00032   class DepthAttribute;
00033   class DirectedLight;
00034   class FaceAttribute;
00035   class GeoNode;
00036   class GeoSet;
00037   class LineAttribute;
00038   class Lines;
00039   class LOD;
00040   class Material;
00041   class ParallelCamera;
00042   class PerspectiveCamera;
00043   class PointAttribute;
00044   class PointLight;
00045   class Points;
00046   class QuadMeshes;
00047   class Quads;
00048   class QuadStrips;
00049   class SpotLight;
00050   class StateAttribute;
00051   class StateVariant;
00052   class Switch;
00053   class Transform;
00054   class TriFans;
00055   class TriStrips;
00056   class VNVector;
00057   template<typename T> class FramedAnimation;
00058   template<typename T> class LinearInterpolatedAnimation;
00059 }
00060
00061
00062 //  Don't need to document the API specifier
00063 #if ! defined( DOXYGEN_IGNORE )
00064 #ifdef NVSGLOADER_EXPORTS
00065 #define NVSGLOADER_API __declspec(dllexport)
00066 #else
00067 #define NVSGLOADER_API __declspec(dllimport)
00068 #endif
00069 #endif  //  DOXYGEN_IGNORE
00070
00072
00076 NVSGLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00077
00079
00084 NVSGLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00085
00087
00089 class NVSGLoader : public nvsg::SceneLoader
00090 {
00091   public :
00092     //  Default constructor.
00093     NVSGLoader();
00094     ~NVSGLoader();
00095
00096   public :
00098
00099     void  deleteThis( void );
00100
00102
00107     const nvsg::Scene * load( const std::string& filename
00108                             , const std::vector<std::string> &searchPaths
00109                             , const nvsg::ViewState *& viewState
00111                             );
00112
00113   private :
00114     void                                                cleanup( void );
00115     bool                                                getNextLine( void );
00116     std::string                                       & getNextToken( void );
00117     const nvsg::Scene                                 * import( const std::string &filename, const nvsg::ViewState *& viewState );
00118     bool                                                onIncompatibleValues( int value0, int value1, const std::string &node, const std::string &field0, const std::string &field1 ) const;
00119     template<typename T> bool                           onInvalidValue( T value, const std::string &node, const std::string &field ) const;
00120     bool                                                onEmptyToken( const std::string &tokenType, const std::string &token ) const;
00121     bool                                                onFileNotFound( const std::string &file ) const;
00122     bool                                                onFilesNotFound( bool found, const std::vector<std::string> &files ) const;
00123     void                                                onUnexpectedEndOfFile( bool error ) const;
00124     void                                                onUnexpectedToken( const std::string &expected, const std::string &token ) const;
00125     void                                                onUnknownToken( const std::string &context, const std::string &token ) const;
00126     bool                                                onUndefinedToken( const std::string &context, const std::string &token ) const;
00127     bool                                                onUnsupportedToken( const std::string &context, const std::string &token ) const;
00128     const nvsg::AnimatedQuads                         * readAnimatedQuads( const char *name );
00129     const nvsg::AnimatedTransform                     * readAnimatedTransform( const char *name );
00130     const nvsg::AnimatedTriangles                     * readAnimatedTriangles( const char *name );
00131     void                                                readAttributes( std::vector<const nvsg::StateAttribute*> &attribs );
00132     const nvsg::Billboard                             * readBillboard( const char *name );
00133     const nvsg::BlendAttribute                        * readBlendAttribute( const char *name );
00134     nvsg::BlendFunction                                 readBlendFunction( void );
00135     bool                                                readBool( void );
00136     bool                                                readCameraToken( nvsg::Camera * pc, const char *token );
00137     const nvsg::CgFx                                  * readCgFx( const char *name );
00138     const nvsg::Node                                  * readChild( const char *token = NULL );
00139     void                                                readChildren( nvsg::Group *g );
00140     size_t                                              readCount( const char *token = NULL );
00141     const nvsg::DepthAttribute                        * readDepthAttribute( const char *name );
00142     nvsg::DepthFunction                                 readDepthFunction( void );
00143     const nvsg::DirectedLight                         * readDirectedLight( const char *name );
00144     DWORD                                               readDWORD( void );
00145     const nvsg::FaceAttribute                         * readFaceAttribute( const char *name );
00146     nvsg::FaceMode                                      readFaceMode( void );
00147     float                                               readFloat( const std::string &token );
00148     void                                                readFloats( std::vector<float> &v );
00149     const nvsg::FramedAnimation<nvmath::Trafo>        * readFramedTrafoAnimation( const char *name );
00150     const nvsg::FramedAnimation<nvsg::VNVector>       * readFramedVNVectorAnimation( const char *name );
00151     const nvsg::GeoNode                               * readGeoNode( const char *name );
00152     const nvsg::Group                                 * readGroup( const char *name );
00153     bool                                                readGroupToken( nvsg::Group *g, const char *token );
00154     bool                                                readIndependentPrimitiveSetToken( nvsg::IndependentPrimitiveSet * ips, const char *token );
00155     void                                                readIndexMesh( nvsg::IndexMesh &im, const char *token );
00156     void                                                readIndexSet( nvsg::IndexSet &v, const char *token );
00157     long                                                readInt( const char *token = NULL );
00158     const nvsg::LinearInterpolatedAnimation<nvmath::Trafo>  * readLinearInterpolatedTrafoAnimation( const char *name );
00159     const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> * readLinearInterpolatedVNVectorAnimation( const char *name );
00160     bool                                                readLightSourceToken( nvsg::LightSource *ls, const std::string &token );
00161     const nvsg::LineAttribute                         * readLineAttribute( const char *name );
00162     const nvsg::Lines                                 * readLines( const char *name );
00163     const nvsg::LineStrips                            * readLineStrips( const char *name );
00164     const nvsg::LOD                                   * readLOD( const char *name );
00165     nvmath::Mat33f                                      readMat33f( void );
00166     nvmath::Mat44f                                      readMat44f( void );
00167     const nvsg::Material                              * readMaterial( const char *name );
00168     bool                                                readMeshedPrimitiveSetToken( nvsg::MeshedPrimitiveSet * mps, const char *token );
00169     void                                                readMeshes( std::vector<nvsg::IndexMesh> &meshes );
00170     std::string                                         readName( const char *t = NULL );
00171     bool                                                readNodeToken( nvsg::Node *n, const char *token );
00172     const nvsg::ParallelCamera                        * readParallelCamera( const char *name );
00173     void                                                readPasses( std::vector<const nvsg::StatePass*> &passes );
00174     const nvsg::PerspectiveCamera                     * readPerspectiveCamera( const char *name );
00175     const nvsg::PointAttribute                        * readPointAttribute( const char *name );
00176     const nvsg::PointLight                            * readPointLight( const char *name );
00177     const nvsg::Points                                * readPoints( const char *name );
00178     bool                                                readPrimitiveSetToken( nvsg::PrimitiveSet * p, const char *token );
00179     const nvsg::QuadMeshes                            * readQuadMeshes( const char *name );
00180     const nvsg::Quads                                 * readQuads( const char *name );
00181     const nvsg::QuadStrips                            * readQuadStrips( const char *name );
00182     bool                                                readQuadsToken( nvsg::Quads *q, const char *token );
00183     nvmath::Quatf                                       readQuatf( const std::string &token );
00184     void                                                readSampler(nvsg::CgFxEffect * effect, const std::string& name);
00185     const nvsg::Scene                                 * readScene( void );
00186     nvsg::Skin                                          readSkin( std::string &token );
00187     const nvsg::SkinnedTriangles                      * readSkinnedTriangles( const char *name );
00188     void                                                readSkins( std::vector<nvsg::Skin> &skins );
00189     const nvsg::SpotLight                             * readSpotLight( const char *name );
00190     const nvsg::StatePass                             * readStatePass( const char *name );
00191     const nvsg::StateSet                              * readStateSet( const char *name );
00192     const nvsg::StateVariant                          * readStateVariant( const char *name );
00193     bool                                                readStrippedPrimitiveSetToken( nvsg::StrippedPrimitiveSet * sps, const char *token );
00194     void                                                readStrips( std::vector<nvsg::IndexSet> &strips );
00195     const nvsg::Switch                                * readSwitch( const char *name );
00196     void                                                readTexGen( nvsg::TextureAttributeItem * texItem );
00197     const nvsg::TextureAttribute                      * readTextureAttribute( const char *name );
00198     const nvsg::TextureAttributeItem                  * readTextureAttributeItem( const char *name );
00199     void                                                readTextureAttributeItems(std::vector<const nvsg::TextureAttributeItem*>& texItems);
00200     nvsg::TextureEnvMode                                readTextureEnvMode( void );
00201     nvsg::TextureMagFilterMode                          readTextureMagFilterMode( void );
00202     nvsg::TextureMinFilterMode                          readTextureMinFilterMode( void );
00203     nvsg::TextureWrapMode                               readTextureWrapMode( void );
00204     const nvsg::Transform                             * readTransform( const char *name );
00205     bool                                                readTransformToken( nvsg::Transform *t, const char *token );
00206     const nvsg::Triangles                             * readTriangles( const char *name );
00207     bool                                                readTrianglesToken( nvsg::Triangles *t, const char *token );
00208     const nvsg::TriFans                               * readTriFans( const char *name );
00209     const nvsg::TriStrips                             * readTriStrips( const char *name );
00210     void                                                readTweak(nvsg::CgFxEffect * effect, const std::string& name);
00211     void                                                readVariants( std::map<nvsg::VariantKey,const nvsg::StateVariant*> &variants );
00212     nvmath::Vec2f                                       readVec2f( const std::string &token );
00213     void                                                readVec2fs( std::vector<nvmath::Vec2f> &vecs );
00214     nvmath::Vec3f                                       readVec3f( const std::string &token );
00215     void                                                readVec3fs( std::vector<nvmath::Vec3f> &vecs );
00216     nvmath::Vec4f                                       readVec4f( const std::string &token );
00217     void                                                readVec4fs( std::vector<nvmath::Vec4f> &vecs );
00218     const nvsg::VertexAttributeSet                    * readVertexAttributeSet( const char *name );
00219     const nvsg::ViewState                             * readViewState( void );
00220     bool                                                testNVSGVersion( void );
00221
00222     template<size_t n>            nvsg::Face<n> readFace( const char *token );
00223     template<size_t n>            void          readFaces( std::vector<nvsg::Face<n> > &faces );
00224     template<typename ObjectType> void          storeNamedObject(const std::string& name, std::map<std::string, const ObjectType*>& container, const ObjectType * obj);
00225
00226   private :
00227     std::map<std::string,const nvsg::AnimatedQuads*>                                m_animatedQuads;
00228     std::map<std::string,const nvsg::AnimatedTransform*>                            m_animatedTransforms;
00229     std::map<std::string,const nvsg::AnimatedTriangles*>                            m_animatedTriangles;
00230     std::map<std::string,const nvsg::Billboard*>                                    m_billboards;
00231     std::map<std::string,const nvsg::BlendAttribute*>                               m_blendAttributes;
00232     std::map<std::string,const nvsg::CgFx*>                                         m_cgfxs;
00233     nvmath::Vec3f                                                                   m_cameraDirection;
00234     nvmath::Vec3f                                                                   m_cameraUpVector;
00235     char                                                                          * m_currentLine;
00236     size_t                                                                          m_currentLineLength;
00237     std::string                                                                     m_currentString;
00238     std::string                                                                     m_currentToken;
00239     std::map<std::string,const nvsg::DepthAttribute*>                               m_depthAttributes;
00240     std::map<std::string,const nvsg::DirectedLight*>                                m_directedLights;
00241     bool                                                                            m_eof;
00242     std::map<std::string,const nvsg::FaceAttribute*>                                m_faceAttributes;
00243     std::map<std::string,const nvsg::FramedAnimation<nvmath::Trafo>*>               m_framedTrafoAnimations;
00244     std::map<std::string,const nvsg::FramedAnimation<nvsg::VNVector>*>              m_framedVNVectorAnimations;
00245     std::map<std::string,const nvsg::GeoNode*>                                      m_geoNodes;
00246     std::map<std::string,const nvsg::Group*>                                        m_groups;
00247     std::ifstream                                                                   m_ifs;
00248     size_t                                                                          m_line;
00249     std::map<std::string,const nvsg::LinearInterpolatedAnimation<nvmath::Trafo>*>   m_linearInterpolatedTrafoAnimations;
00250     std::map<std::string,const nvsg::LinearInterpolatedAnimation<nvsg::VNVector>*>  m_linearInterpolatedVNVectorAnimations;
00251     std::map<std::string,const nvsg::LineAttribute*>                                m_lineAttributes;
00252     std::map<std::string,const nvsg::Lines*>                                        m_lines;
00253     std::map<std::string,const nvsg::LineStrips*>                                   m_lineStrips;
00254     std::map<std::string,const nvsg::LOD*>                                          m_LODs;
00255     std::map<std::string,const nvsg::Material*>                                     m_materials;
00256     char                                                                          * m_nextToken;
00257     std::map<std::string,const nvsg::ParallelCamera*>                               m_parallelCameras;
00258     std::map<std::string,const nvsg::PerspectiveCamera*>                            m_perspectiveCameras;
00259     std::map<std::string,const nvsg::PointAttribute*>                               m_pointAttributes;
00260     std::map<std::string,const nvsg::PointLight*>                                   m_pointLights;
00261     std::map<std::string,const nvsg::Points*>                                       m_points;
00262     std::map<std::string,const nvsg::QuadMeshes*>                                   m_quadMeshes;
00263     std::map<std::string,const nvsg::Quads*>                                        m_quads;
00264     std::map<std::string,const nvsg::QuadStrips*>                                   m_quadStrips;
00265     const nvsg::Scene                                                             * m_scene;
00266     std::map<std::string,const nvsg::SkinnedTriangles*>                             m_skinnedTriangles;
00267     std::map<std::string,const nvsg::SpotLight*>                                    m_spotLights;
00268     std::map<std::string,const nvsg::StatePass*>                                    m_statePasses;
00269     std::map<std::string,const nvsg::StateSet*>                                     m_stateSets;
00270     std::map<std::string,const nvsg::StateVariant*>                                 m_stateVariants;
00271     std::vector<std::string>                                                        m_searchPaths;
00272     std::map<std::string,const nvsg::Switch*>                                       m_switches;
00273     std::map<std::string,const nvsg::TextureAttribute*>                             m_textureAttributes;
00274     std::map<std::string,const nvsg::TextureAttributeItem*>                         m_textureAttributeItems;
00275     std::map<std::string,const nvsg::Transform*>                                    m_transforms;
00276     std::map<std::string,const nvsg::Triangles*>                                    m_triangles;
00277     std::map<std::string,const nvsg::TriFans*>                                      m_triFans;
00278     std::map<std::string,const nvsg::TriStrips*>                                    m_triStrips;
00279     std::map<std::string,const nvsg::VertexAttributeSet*>                           m_vertexAttributeSets;
00280 };
00281
00282 inline void NVSGLoader::deleteThis( void )
00283 {
00284   delete this;
00285 }
00286
00287 template<size_t n>
00288 inline nvsg::Face<n> NVSGLoader::readFace( const char *token )
00289 {
00290   Face<n> f;
00291   f[0] = (UINT) readCount( token );
00292   for ( size_t i=1 ; i<n ; i++ )
00293   {
00294     f[i] = (UINT) readCount();
00295   }
00296   return( f );
00297 }
00298
00299 template<size_t n>
00300 inline void  NVSGLoader::readFaces( std::vector<nvsg::Face<n> > &faces )
00301 {
00302   faces.clear();
00303   const char * token = getNextToken().c_str();
00304   onUnexpectedToken( "[", token );
00305   token = getNextToken().c_str();
00306   while ( strcmp( token, "]" ) )
00307   {
00308     faces.push_back( readFace<n>( token ) );
00309     token = getNextToken().c_str();
00310   }
00311 }
00312
00313 template <typename ObjectType>
00314 inline void NVSGLoader::storeNamedObject(const std::string& name, std::map<std::string, const ObjectType*>& container, const ObjectType * obj)
00315 {
00316   if ( obj )
00317   {
00318     if ( container.find( name ) != container.end() )
00319     {
00320       container[name]->removeRef();
00321     }
00322     obj->addRef();
00323     container[name] = obj;
00324   }
00325 }
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:42 2006 for NVSGSDK by NVIDIA


NVSGSaver.h File Reference

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

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 Fri Aug 4 08:34:44 2006 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
00014 #include  "nvsg/nvsgapi.h"
00015 #include  "nvtraverser/Traverser.h"
00016 #include  "nvsg/AnimatedQuads.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  <set>
00023
00024
00025 //  Don't need to document the API specifier
00026 #if ! defined( DOXYGEN_IGNORE )
00027 #ifdef NVSGSAVER_EXPORTS
00028 #define NVSGSAVER_API __declspec(dllexport)
00029 #else
00030 #define NVSGSAVER_API __declspec(dllimport)
00031 #endif
00032 #endif  //  DOXYGEN_IGNORE
00033
00035
00040 NVSGSAVER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00041
00043
00048 NVSGSAVER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00049
00051
00052 class NVSGSaveTraverser : public nvtraverser::Traverser
00053 {
00054   public:
00056     NVSGSaveTraverser();
00057
00059     void  setFILE( FILE *fh
00060                  );
00061
00063
00065     NVSGSAVER_API virtual void setViewState( const nvsg::ViewState * viewState
00066                                            );
00067
00068   protected:
00070
00071     void doApply( const nvsg::Scene * scene
00072     );
00073
00074     // overloads to process concrete types for saving
00075     // ...Cameras
00077
00079     virtual void handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root);
00080
00082
00084     virtual void handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root);
00085
00086     // ...Nodes
00088
00089     virtual void handleBillboard(const nvsg::Billboard *p);
00090
00092
00093     virtual void handleGeoNode(const nvsg::GeoNode *p);
00094
00096
00097     virtual void handleGroup( const nvsg::Group *p );
00098
00100
00101     virtual void handleTransform(const nvsg::Transform *p);
00102
00104
00106     virtual void handleAnimatedTransform(const nvsg::AnimatedTransform *p);
00107
00109
00111     virtual void handleLOD(const nvsg::LOD *p);
00112
00114
00116     virtual void handleSwitch(const nvsg::Switch *p);
00117
00119
00121     virtual void handleDirectedLight(const nvsg::DirectedLight *p);
00122
00124
00126     virtual void handlePointLight(const nvsg::PointLight *p);
00127
00129
00131     virtual void handleSpotLight(const nvsg::SpotLight *p);
00132
00133     // ...StateSet
00135
00137     virtual void handleStateSet(const nvsg::StateSet *p);
00138
00140
00142     virtual void handleStateVariant(const nvsg::StateVariant *p);
00143
00145
00147     virtual void handleStatePass(const nvsg::StatePass *p);
00148
00149     // ...StateAttribs
00151
00152     virtual void handleBlendAttribute(const nvsg::BlendAttribute *p);
00153
00155
00156     virtual void handleCgFx(const nvsg::CgFx *p);
00157
00159
00160     virtual void handleDepthAttribute(const nvsg::DepthAttribute *p);
00161
00163
00164     virtual void handleFaceAttribute(const nvsg::FaceAttribute *p);
00165
00167
00168     virtual void handleLineAttribute(const nvsg::LineAttribute *p);
00169
00171
00172     virtual void handleMaterial(const nvsg::Material *p);
00173
00175
00176     virtual void handlePointAttribute(const nvsg::PointAttribute *p);
00177
00179
00180     virtual void handleTextureAttribute(const nvsg::TextureAttribute *p);
00181
00183
00184     virtual void handleTextureAttributeItem(const nvsg::TextureAttributeItem * p, size_t tu);
00185
00186     // ...GeoSets
00188
00189     virtual void handleTriangles(const nvsg::Triangles *p);
00190
00192
00194     virtual void handleAnimatedTriangles(const nvsg::AnimatedTriangles *p);
00195
00197
00199     virtual void handleSkinnedTriangles(const nvsg::SkinnedTriangles *p);
00200
00202
00203     virtual void handleTriFans(const nvsg::TriFans *p);
00204
00206
00207     virtual void handleTriStrips(const nvsg::TriStrips *p);
00208
00210
00211     virtual void handleQuadMeshes(const nvsg::QuadMeshes *p);
00212
00214
00215     virtual void handleQuads(const nvsg::Quads *p);
00216
00218
00220     virtual void handleAnimatedQuads(const nvsg::AnimatedQuads *p);
00221
00223
00224     virtual void handleQuadStrips(const nvsg::QuadStrips *p);
00225
00227
00228     virtual void handleLines(const nvsg::Lines *p);
00229
00231
00232     virtual void handleLineStrips(const nvsg::LineStrips *p);
00233
00235
00236     virtual void handlePoints(const nvsg::Points *p);
00237
00239
00240     virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *p );
00241
00242     // ... Animations
00244
00245     virtual void handleFramedTrafoAnimation(const nvsg::FramedAnimation<nvmath::Trafo> *p);
00246
00248
00249     virtual void handleFramedVNVectorAnimation(const nvsg::FramedAnimation<nvsg::VNVector> *p);
00250
00252
00253     virtual void handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> *p);
00254
00256
00257     virtual void handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> *p);
00258
00259 private:
00260     const   std::string  getName( const std::string &name );
00261     void    vertexAttributeSet( const nvsg::VertexAttributeSet *p, bool doVerticesAndNormals = true );
00262     std::string  getObjectName( const nvsg::Object *p, std::string namePrefix, int &counter );
00263     void    groupData( const nvsg::Group *p );
00264     void    independentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, size_t primitiveSize, bool doVerticesAndNormals = true );
00265     void    initUnnamedCounters( void );
00266     bool    isFirstTime( const nvutil::RCObject *p );
00267     void    lightSourceData( const nvsg::LightSource *p );
00268     void    nodeData( const nvsg::Node *p );
00269     void    simpleCameraData( const nvsg::Camera *p );
00270     void    meshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p );
00271     void    strippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p );
00272     void    writeTweakable( const nvsg::CgFxEffect * effect, nvsg::CgFxParameter tweak );
00273     void    writeSampler( const nvsg::CgFxEffect * effect, nvsg::CgFxParameter sampler );
00274
00275   private:
00276     FILE * m_fh;
00277
00278     std::set<const nvutil::RCObject *>                m_sharedRCObjects;
00279     std::map<nvsg::DataID, std::string>               m_sharedData;
00280     std::vector<std::pair<std::string,std::string> >  m_geometryNames;
00281     std::vector<const nvsg::StateAttribute *>         m_attributes;
00282     std::vector<const nvsg::StatePass*>               m_passes;
00283     std::vector<const nvsg::StateVariant*>            m_variants;
00284     std::vector<const nvsg::TextureAttributeItem*>    m_texAttribItems;
00285     const nvsg::StateSet *                            m_currentStateSet;
00286     std::map<const nvsg::Object *, std::string>       m_objectNames;
00287     int m_unnamedAnimatedQuadsCounter;
00288     int m_unnamedAnimatedTransformCounter;
00289     int m_unnamedAnimatedTrianglesCounter;
00290     int m_unnamedBillboardCounter;
00291     int m_unnamedBlendAttributeCounter;
00292     int m_unnamedCgFxCounter;
00293     int m_unnamedDepthAttributeCounter;
00294     int m_unnamedDirectedLightCounter;
00295     int m_unnamedFaceAttributeCounter;
00296     int m_unnamedFramedTrafoAnimationCounter;
00297     int m_unnamedFramedVNVectorAnimationCounter;
00298     int m_unnamedGeoNodeCounter;
00299     int m_unnamedGroupCounter;
00300     int m_unnamedJitterCameraCounter;
00301     int m_unnamedLinearInterpolatedTrafoAnimation;
00302     int m_unnamedLinearInterpolatedVNVectorAnimationCounter;
00303     int m_unnamedLineAttributeCounter;
00304     int m_unnamedLinesCounter;
00305     int m_unnamedLineStripsCounter;
00306     int m_unnamedLODCounter;
00307     int m_unnamedMaterialCounter;
00308     int m_unnamedParallelCameraCounter;
00309     int m_unnamedPerspectiveCameraCounter;
00310     int m_unnamedPointAttributeCounter;
00311     int m_unnamedPointLightCounter;
00312     int m_unnamedPointsCounter;
00313     int m_unnamedQuadMeshesCounter;
00314     int m_unnamedQuadsCounter;
00315     int m_unnamedQuadStripsCounter;
00316     int m_unnamedSkinnedTrianglesCounter;
00317     int m_unnamedSpotLightCounter;
00318     int m_unnamedStatePassCounter;
00319     int m_unnamedStateSetCounter;
00320     int m_unnamedStateVariantCounter;
00321     int m_unnamedStereoCameraCounter;
00322     int m_unnamedSwitchCounter;
00323     int m_unnamedTextureAttributeCounter;
00324     int m_unnamedTextureAttributeItemCounter;
00325     int m_unnamedTransformCounter;
00326     int m_unnamedTrianglesCounter;
00327     int m_unnamedTriFansCounter;
00328     int m_unnamedTriStripsCounter;
00329     int m_unnamedVertexAttributeSetCounter;
00330 };
00331
00333
00335 class NVSGSaver : public nvsg::SceneSaver
00336 {
00337   public :
00339
00340     void  deleteThis( void );
00341
00343
00344     bool  save( const nvsg::Scene &scene
00345               , const nvsg::ViewState *viewState
00346               , const std::string& filename
00347               );
00348
00349   private :
00350     NVSGSaveTraverser m_traverser;
00351 };
00352
00353 inline void NVSGSaver::deleteThis( void )
00354 {
00355   delete this;
00356 }
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:44 2006 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 // The build group should read this before they start
00024 // compiling the solution and set the environment variable
00025 // NVSGVERSIONTAG regarding this value. The version tag is the major version number.
00026 // NVSGVERSIONTAG=1
00027 #define NVSG_VER_MARKETING   2
00028 #define NVSG_VER_MAJOR       1
00029 #define NVSG_VER_MINOR       1
00030 #define NVSG_VER_BUGFIX      10
00031
00032 //#define NVSG_BETA
00033
00034 #ifdef LINUX
00035   #define NVSG_BETA
00036 #elif defined _WIN64
00037   #define NVSG_BETA
00038 #else
00039   #define NVSG_BETA
00040 #endif
00041
00042 #ifdef NVSG_ALPHA
00043   #define ALPHA
00044 #endif
00045
00046 #ifdef NVSG_BETA
00047   #define BETA
00048 #endif
00049
00050 // MaKe STRing helper macro
00051 #define MKSTR(s)    MKSTR_i(s)
00052 #define MKSTR_i(s)  MKSTR_ii(s)
00053 #define MKSTR_ii(s) #s
00054
00055 // conditionally add a leading zero to the single parts of the version string
00056 #if NVSG_VER_MARKETING < 10
00057 #define NVSG_VER_MARKETING_STR  "0" MKSTR(NVSG_VER_MARKETING)
00058 #else
00059 #define NVSG_VER_MARKETING_STR      MKSTR(NVSG_VER_MARKETING)
00060 #endif
00061 #if NVSG_VER_MAJOR < 10
00062 #define NVSG_VER_MAJOR_STR      "0" MKSTR(NVSG_VER_MAJOR)
00063 #else
00064 #define NVSG_VER_MAJOR_STR          MKSTR(NVSG_VER_MAJOR)
00065 #endif
00066 #if NVSG_VER_MINOR < 10
00067 #define NVSG_VER_MINOR_STR      "0" MKSTR(NVSG_VER_MINOR)
00068 #else
00069 #define NVSG_VER_MINOR_STR          MKSTR(NVSG_VER_MINOR)
00070 #endif
00071 #if NVSG_VER_BUGFIX < 10
00072 #define NVSG_VER_BUGFIX_STR     "0" MKSTR(NVSG_VER_BUGFIX)
00073 #else
00074 #define NVSG_VER_BUGFIX_STR         MKSTR(NVSG_VER_BUGFIX)
00075 #endif
00076
00077 #define SDK_VENDOR "NVIDIA"
00078 #define SDK_NAME   "NVSG"
00079
00080 // internal version string
00081 #define _VER_STR   NVSG_VER_MARKETING_STR "."\
00082                    NVSG_VER_MAJOR_STR "."\
00083                    NVSG_VER_MINOR_STR "."\
00084                    NVSG_VER_BUGFIX_STR
00085
00086 // no need to update these
00087 //
00088 #ifdef ALPHA
00089   #if !defined(NDEBUG)
00090     #define VERSION_STR   _VER_STR " alpha" " (DEBUG)"
00091   #else  //DEBUG
00092     #define VERSION_STR   _VER_STR " alpha"
00093   #endif //DEBUG
00094 #else
00095   #ifdef BETA
00096     #if !defined(NDEBUG)
00097       #define VERSION_STR   _VER_STR " beta (DEBUG)"
00098     #else  //DEBUG
00099       #define VERSION_STR   _VER_STR " beta"
00100     #endif //DEBUG
00101   #else  //BETA
00102     #if !defined(NDEBUG)
00103       #define VERSION_STR   _VER_STR " (DEBUG)"
00104     #else  //DEBUG
00105       #define VERSION_STR   _VER_STR
00106     #endif //DEBUG
00107   #endif //BETA
00108 #endif
00109
00110 #define COPYRIGHT  SDK_VENDOR" "SDK_NAME" Version "VERSION_STR"\n© Copyright 2006 NVIDIA Corporation\n";
00111
00112 #endif  //  DOXYGEN_IGNORE
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


nvtraverser.h File Reference

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Fri Aug 4 08:34:44 2006 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 Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:45 2006 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 Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:53 2006 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 Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


Object.h File Reference

#include "nvsgcommon.h"
#include "nvutil/RCObject.h"
#include "nvutil/SWMRSync.h"
#include "nvsg/DAL.h"
#include "nvutil/Incarnation.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 Fri Aug 4 08:34:55 2006 for NVSGSDK by NVIDIA


Object.h Source File

Object.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 #include  "nvutil/SWMRSync.h"
00019 #include  "nvsg/DAL.h"
00020 #include  "nvutil/Incarnation.h"
00021 #include  <typeinfo>
00022
00023 namespace nvsg
00024 {
00030   typedef unsigned long long DataID;
00031
00042   enum
00043   {
00044     OC_INVALID = 0xFFFFFFFF
00045   , OC_OBJECT = 0
00046   // nodes (0x00-0x1F)
00047   , OC_NODE = OC_OBJECT
00048   , OC_GEONODE
00049   , OC_GROUP
00050   , OC_LOD
00051   , OC_SWITCH
00052   , OC_TRANSFORM
00053   , OC_ANIMATEDTRANSFORM
00054   , OC_DIRECTEDLIGHT
00055   , OC_POINTLIGHT
00056   , OC_SPOTLIGHT
00057   , OC_BILLBOARD
00058   // drawables (0x20-0x3F)
00059   , OC_DRAWABLES = 0x20
00060   , OC_VERTEX_ATTRIBUTE_SET
00061   , OC_QUADS
00062   , OC_ANIMATEDQUADS
00063   , OC_QUADSTRIPS
00064   , OC_TRIANGLES
00065   , OC_ANIMATEDTRIANGLES
00066   , OC_SKINNEDTRIANGLES
00067   , OC_TRISTRIPS
00068   , OC_LINES
00069   , OC_LINESTRIPS
00070   , OC_TRIFANS
00071   , OC_POINTS
00072   , OC_SHAPE
00073   , OC_BITMAP
00074   , OC_PIXMAP
00075   , OC_MAPELEMENT
00076   , OC_MAPARRAY
00077   , OC_MAPMATRIX
00078   , OC_MAPLIST
00079   , OC_QUADMESHES
00080   // states (0x40-0x5F)
00081   , OC_STATESET = 0x40
00082   , OC_STATEVARIANT
00083   , OC_STATEPASS
00084   , OC_STATEATTRIBUTE
00085   , OC_CGFX
00086   , OC_FACEATTRIBUTE
00087   , OC_MATERIAL
00088   , OC_TEXTUREATTRIBUTE
00089   , OC_TEXTUREATTRIBUTEITEM
00090   , OC_STATESETEXT
00091   , OC_LINEATTRIBUTE
00092   , OC_POINTATTRIBUTE
00093   , OC_BLENDATTRIBUTE
00094   , OC_DEPTHATTRIBUTE
00095   // animations (0x60-0x7F)
00096   , OC_ANIMATION = 0x60
00097   , OC_FRAMEDTRAFOANIMATION
00098   , OC_FRAMEDVNVECTORANIMATION
00099   , OC_LINEARINTERPOLATEDTRAFOANIMATION
00100   , OC_LINEARINTERPOLATEDVNVECTORANIMATION
00101   // cameras (0x80-0x9F)
00102   , OC_CAMERA = 0x80
00103   , OC_PARALLELCAMERA
00104   , OC_PERSPECTIVECAMERA
00105   // highlight objects (0xA0-0xBF)
00106   , OC_HIGHLIGHTOBJECT = 0xA0
00107   , OC_HIGHLIGHTBOX
00108   , OC_HIGHLIGHTEDGES
00109   // custom (0xC0 and higher)
00110   , OC_CUSTOMOBJECT = 0xC0
00111   };
00112
00123   class Object : public nvutil::RCObject  // an object is reference-counted
00124                , public nvutil::ISWMRSync // an object is lockable
00125                , public DALHost           // an object can host DAL data
00126   {
00127   public:
00128
00142     unsigned int getObjectCode() const;
00143
00171     NVSG_API virtual unsigned int getHigherLevelObjectCode(unsigned int oc) const;
00172
00194     NVSG_API virtual bool isDataShared() const;
00195
00207     NVSG_API virtual DataID getDataID() const;
00208
00219     NVSG_API const nvutil::Incarnation& getIncarnation() const;
00220
00228     NVSG_API void increaseIncarnation();
00229
00238     NVSG_API void setName(const std::string& name);
00239
00247     NVSG_API const std::string& getName() const;
00248
00265     NVSG_API virtual bool isEquivalent( const Object * object
00266                                       , bool ignoreNames = true
00267                                       , bool deepCompare = false) const;
00268
00269   protected: // accessible for derived classes
00270
00275     NVSG_API Object();
00276
00281     NVSG_API Object( const Object& rhs );
00282
00287     NVSG_API virtual ~Object();
00288
00298     NVSG_API Object & operator=(const Object & rhs);
00299
00306     NVSG_API virtual void validateIncarnation() const;
00307
00308
00318     NVSG_API virtual void invalidateIncarnation();
00319
00320   protected:
00321
00347     unsigned int m_objectCode;
00348
00349   private:
00350     std::string                 * m_name;
00351     mutable nvutil::Incarnation   m_incarnation;
00352     mutable bool                  m_incarnationValid;
00353   };
00354
00355   inline unsigned int Object::getObjectCode() const
00356   {
00357     NVSG_TRACE();
00358     return m_objectCode;
00359   }
00360
00362
00363   template<typename T>
00364   inline bool isTypeOf( const Object *p )
00365   {
00366     return( dynamic_cast<const T *>( p ) != NULL );
00367   }
00368
00370
00371   inline bool areOfSameType( const Object &p0, const Object &p1 )
00372   { // found not initialized object codes if one of the following fires
00373     NVSG_ASSERT(p0.getObjectCode()!=OC_INVALID);
00374     NVSG_ASSERT(p1.getObjectCode()!=OC_INVALID);
00375     return( p0.getObjectCode() == p1.getObjectCode() );
00376   }
00377
00378 } //  namespace nvsg
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:57 2006 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
00017 #include "nvsgcommon.h"
00018
00019 #include "nvtraverser/Traverser.h"
00020
00021 namespace nvtraverser
00022 {
00024   class OptimizeTraverser : public Traverser
00025   {
00026     public:
00028       NVSG_API OptimizeTraverser( void );
00029
00030     public:
00032
00034       NVSG_API bool getIgnoreNames( void ) const;
00035
00037
00038       NVSG_API void setIgnoreNames( bool ignore
00039                                   );
00040
00042
00043       NVSG_API bool getTreeModified( void ) const;
00044
00045     protected:
00047       NVSG_API virtual ~OptimizeTraverser( void );
00048
00050       NVSG_API virtual void doApply( const nvsg::Scene * scene );
00051
00052       NVSG_API void setTreeModified( void );
00053
00054     private:
00055       bool  m_ignoreNames;
00056       bool  m_treeModified;
00057   };
00058
00059   inline bool OptimizeTraverser::getIgnoreNames( void ) const
00060   {
00061     return( m_ignoreNames );
00062   }
00063
00064   inline void OptimizeTraverser::setIgnoreNames( bool ignore )
00065   {
00066     m_ignoreNames = ignore;
00067   }
00068
00069   inline bool OptimizeTraverser::getTreeModified( void ) const
00070   {
00071     return( m_treeModified );
00072   }
00073
00074   inline void OptimizeTraverser::setTreeModified( void )
00075   {
00076     m_treeModified = true;
00077   }
00078 }
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:34:58 2006 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 static const ParallelCamera * create();
00031
00039       NVSG_API static const ParallelCamera * createFromBase( const Camera &rhs );
00040
00044       NVSG_API virtual const ParallelCamera * clone() const;
00045
00049       NVSG_API virtual nvmath::Mat44f getProjection() const;
00050
00054       NVSG_API virtual nvmath::Mat44f getInverseProjection()  const;
00055
00069       NVSG_API virtual void getPickRay( int x
00070                                       , int y
00071                                       , int w
00072                                       , int h
00073                                       , nvmath::Vec3f & rayOrigin
00074                                       , nvmath::Vec3f & rayDir ) const;
00075
00080       NVSG_API ParallelCamera & operator=(const ParallelCamera & rhs);
00081
00086       NVSG_API virtual CullCode determineCullCode( const nvmath::Sphere3f &sphere ) const;
00087
00088     protected:
00092       NVSG_API ParallelCamera();
00093
00100       NVSG_API explicit ParallelCamera( const Camera &rhs );
00101
00106       NVSG_API ParallelCamera( const ParallelCamera &rhs );
00107
00112       NVSG_API virtual ~ParallelCamera();
00113   };
00114 } // namespace
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


Path.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.h"
#include "nvmath/Mat44f.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 Fri Aug 4 08:34:58 2006 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
00017 #include "nvsg/Object.h"
00018 #include "nvmath/Mat44f.h"
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 const Object * getHead() const;
00060
00067       NVSG_API const Object * getTail() const;
00068
00076       NVSG_API const Object * getFromHead(size_t i) const;
00077
00085       NVSG_API const Object * getFromTail(size_t i) const;
00086
00092       NVSG_API void pop();
00093
00100       NVSG_API void push(const Object * pObject);
00101
00110       NVSG_API void truncate(size_t 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<const Object *> m_path;
00129   };
00130
00131   // - - - - - - - - - - - - - - - - - - -
00132   // inlines
00133   // - - - - - - - - - - - - - - - - - - -
00134
00135   inline const Object * Path::getHead() const
00136   {
00137     NVSG_TRACE();
00138     return( m_path.empty() ? NULL : m_path.front() );
00139   }
00140
00141   inline const Object * Path::getTail() const
00142   {
00143     NVSG_TRACE();
00144     return( m_path.empty() ? NULL : m_path.back() );
00145   }
00146
00147   inline const Object * Path::getFromHead( size_t i ) const
00148   {
00149     NVSG_TRACE();
00150     NVSG_ASSERT(0 <= i && i < m_path.size());
00151     return( m_path[i] );
00152   }
00153
00154   inline const Object * Path::getFromTail( size_t 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 Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:34:59 2006 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 static const PerspectiveCamera * create();
00031
00039       NVSG_API static const PerspectiveCamera * createFromBase( const Camera &rhs );
00040
00044       NVSG_API virtual const PerspectiveCamera * clone() const;
00045
00050       NVSG_API float getFieldOfView() const;
00051
00056       NVSG_API void setFieldOfView( float fov );
00057
00059
00067       NVSG_API virtual void setFocusDistance( float fd );
00068
00072       NVSG_API virtual nvmath::Mat44f getProjection() const;
00073
00077       NVSG_API virtual nvmath::Mat44f getInverseProjection() const;
00078
00091       NVSG_API virtual void getPickRay( int x
00092                                       , int y
00093                                       , int w
00094                                       , int h
00095                                       , nvmath::Vec3f & rayOrigin
00096                                       , nvmath::Vec3f & rayDir ) const;
00097
00102       NVSG_API PerspectiveCamera & operator=(const PerspectiveCamera & rhs);
00103
00108       NVSG_API virtual CullCode determineCullCode( const nvmath::Sphere3f &sphere ) const;
00109
00110     protected:
00114       NVSG_API PerspectiveCamera();
00115
00122       NVSG_API explicit PerspectiveCamera( const Camera &rhs );
00123
00128       NVSG_API PerspectiveCamera( const PerspectiveCamera &rhs );
00129
00134       NVSG_API virtual ~PerspectiveCamera();
00135   };
00136
00137   inline float PerspectiveCamera::getFieldOfView() const
00138   {
00139     NVSG_TRACE();
00140     return( 2.0f * atanf( 0.5f * getWindowSize()[1] / getFocusDistance() ) );
00141   }
00142 } // namespace
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


Pixmap.h File Reference

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

Include dependency graph for Pixmap.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Fri Aug 4 08:35:00 2006 for NVSGSDK by NVIDIA


Pixmap.h Source File

Pixmap.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/Map.h"
00017
00018 namespace nvsg
00019 {
00020 #if 0
00021
00022   class Pixmap : public Map
00023   {
00025
00026       NVSG_API static const Pixmap * create( size_t width, size_t height, PixelFormat format, PixelDataType type, unsigned char * data );
00027
00029
00030       NVSG_API virtual const Pixmap * clone( void ) const;
00031
00032     protected:
00034       NVSG_API Pixmap( size_t width, size_t height, PixelFormat format, PixelDataType type, unsigned char * data );
00035
00037       NVSG_API Pixmap( const Pixmap &rhs );
00038
00040       NVSG_API virtual ~Pixmap(void);
00041
00042     private:
00043       Pixmap( void );
00044
00045     private:
00046       PixelFormat   m_format;
00047       PixelDataType m_type;
00048   };
00049 #endif
00050 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


Plane3f.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvmath/Vec3f.h"

Include dependency graph for Plane3f.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 Fri Aug 4 08:35:02 2006 for NVSGSDK by NVIDIA


Plane3f.h Source File

Plane3f.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/Vec3f.h"
00018
00019 namespace nvmath
00020 {
00022
00024   class Plane3f
00025   {
00026     public:
00028
00029       NVSG_API Plane3f( void );
00030
00032       NVSG_API Plane3f( const Vec3f &n
00033                       , float c
00034                       );
00035
00037       NVSG_API Plane3f( const Vec3f &n
00038                       , const Vec3f &p
00039                       );
00040
00042       NVSG_API Plane3f( const Vec3f &p0
00043                       , const Vec3f &p1
00044                       , const Vec3f &p2
00045                       );
00046
00048
00049       NVSG_API Plane3f operator-( void ) const;
00050
00052
00053       NVSG_API Plane3f & operator=( const Plane3f &pl
00054                                   );
00055
00057
00060       NVSG_API bool operator==( const Plane3f& pl
00061                               ) const;
00062
00064
00067       NVSG_API bool operator!=( const Plane3f& pl
00068                               ) const;
00069
00071
00074       NVSG_API float operator()( const Vec3f &p
00075                                ) const;
00076
00078
00079       NVSG_API Vec3f & n( void );
00080
00082
00083       NVSG_API const Vec3f & n( void ) const;
00084
00086
00087       NVSG_API float & c( void );
00088
00090
00091       NVSG_API const float & c( void ) const;
00092
00093     private:
00094       Vec3f m_normal;
00095       float m_offset;
00096   };
00097
00098   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00099   // non-member functions
00100   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00104   inline bool areOnOppositeSides( const Plane3f &plane
00105                                 , const Vec3f &p0
00106                                 , const Vec3f &p1
00107                                 )
00108   {
00109     return( plane( p0 ) * plane( p1 ) < 0 );
00110   }
00111
00115   inline bool areOnSameSide( const Plane3f &plane
00116                            , const Vec3f &p0
00117                            , const Vec3f &p1
00118                            )
00119   {
00120     return( plane( p0 ) * plane( p1 ) > 0 );
00121   }
00122
00126   inline float signedDistance( const Plane3f &pl
00127                              , const Vec3f &p
00128                              )
00129   {
00130     return( pl( p ) );
00131   }
00132
00136   inline float distance( const Plane3f &pl
00137                        , const Vec3f &p
00138                        )
00139   {
00140     return( fabsf( pl( p ) ) );
00141   }
00142
00146   inline Vec3f nearestPoint( const Plane3f &pl
00147                            , const Vec3f &p
00148                            )
00149   {
00150     return( p - pl( p ) * pl.n() );
00151   }
00152
00153   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00154   // inlines
00155   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00156   inline Plane3f Plane3f::operator-( void ) const
00157   {
00158     return( Plane3f( -m_normal, -m_offset ) );
00159   }
00160
00161   inline Plane3f & Plane3f::operator=( const Plane3f &pl )
00162   {
00163     m_normal = pl.n();
00164     m_offset = pl.c();
00165     return( *this );
00166   }
00167
00168   inline bool Plane3f::operator==( const Plane3f &pl ) const
00169   {
00170     return( m_normal == pl.n() && ( fabsf( m_offset - pl.c() ) < FLT_EPSILON ) );
00171   }
00172
00173   inline bool Plane3f::operator!=( const Plane3f &pl ) const
00174   {
00175     return( ! (this->operator==( pl )) );
00176   }
00177
00178   inline Vec3f & Plane3f::n( void )
00179   {
00180     return( m_normal );
00181   }
00182
00183   inline const Vec3f & Plane3f::n( void ) const
00184   {
00185     return( m_normal );
00186   }
00187
00188   inline float & Plane3f::c( void )
00189   {
00190     return( m_offset );
00191   }
00192
00193   inline const float & Plane3f::c( void ) const
00194   {
00195     return( m_offset );
00196   }
00197
00198 } // end namespace nvmath
Generated on Fri Aug 4 08:33:07 2006 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 "*.dll"

Detailed Description

Generated on Fri Aug 4 08:35:03 2006 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            "*.dll"
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            "*.so"
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
00259 private:
00260   PlugInCallback  * m_cb;
00261 };
00262
00263 inline  PlugIn::PlugIn()
00264 : m_cb(NULL)
00265 {
00266 }
00267
00268 inline  void  PlugIn::setCallback( PlugInCallback *cb, bool throwExceptionOnError )
00269 {
00270   if ( m_cb )
00271   {
00272     m_cb->removeRef();
00273   }
00274   m_cb = cb;
00275   if ( m_cb )
00276   {
00277     m_cb->addRef();
00278     m_cb->setThrowExceptionOnError( throwExceptionOnError );
00279   }
00280 }
00281
00282 inline  const PlugInCallback * PlugIn::callback( void ) const
00283 {
00284   return( m_cb );
00285 }
00286
00287 inline  PlugIn::~PlugIn()
00288 {
00289   if ( m_cb )
00290   {
00291     m_cb->removeRef();
00292   }
00293 }
00294
00296
00303 class PlugInServer
00304 {
00305 public:
00306
00308
00337   friend NVSG_API bool getInterface(
00338     const std::vector<std::string>& searchPath
00339   , const UPIID& piid
00340   , PlugIn *& plugIn
00341   );
00342
00344
00355   friend NVSG_API bool queryInterfaceType(
00356     const std::vector<std::string>& searchPath
00357   , const UPITID& pitid
00358   , std::vector<UPIID>& piids
00359   );
00360
00362
00364   friend NVSG_API void releaseInterface(
00365     const UPIID& piid
00366   );
00367
00369
00372   friend NVSG_API void setPlugInFileFilter(
00373     const std::string& filter
00374   );
00375
00377
00383   friend NVSG_API void addPlugInSearchPath(
00384     const std::string& path
00385     );
00386
00388
00389   friend NVSG_API const std::vector<std::string>& getPlugInSearchPath();
00390
00391   PlugInServer();
00392   ~PlugInServer();
00393
00394 private:
00395   // hidden interface
00396   bool getInterfaceImpl(const std::vector<std::string>& searchPath, const UPIID& piid, PlugIn *& plugIn);
00397   bool queryInterfaceTypeImpl(const std::vector<std::string>& searchPath, const UPITID& pitid, std::vector<UPIID>& piids);
00398   void releaseInterfaceImpl(const UPIID& piid);
00399   void setFileFilterImpl(const std::string& filter);
00400
00401 private:
00402   // private plug-in administration
00403   class PlugInHolder
00404   {
00405   public:
00406     PlugInHolder(PlugIn * plugIn) : m_plugIn(plugIn), m_refCnt(1) {}
00407     void addRef() { ++m_refCnt; }
00408     size_t removeRef() { NVSG_ASSERT(m_refCnt>0); return --m_refCnt; }
00409     PlugIn * getPlugIn() const { return m_plugIn; }
00410   private:
00411     PlugIn * m_plugIn;
00412     size_t   m_refCnt;
00413   };
00414   bool findPlugIns(const std::vector<std::string>& searchPath, std::vector<std::string>& plugIns);
00415   bool registerPlugIn(const std::string& fileName, const UPIID& piid, PlugIn *& plugIn);
00416   typedef std::map< UPIID, PlugInHolder*> PlugInMap;
00417   PlugInMap m_plugIns;
00418   std::string m_filter;
00419   std::vector<std::string> m_searchPath;  // the search path for PlugIn DLLs
00420 };
00421
00423 typedef Singleton<PlugInServer> PIS;
00424
00425 } // namespace nvutil
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:04 2006 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       } PIC_ERROR;
00044
00046       typedef enum
00047       {
00048         PICW_FILE_EMPTY,
00049         PICW_FILE_NOT_FOUND,
00050         PICW_FILES_NOT_FOUND,
00051         PICW_EMPTY_TOKEN,
00052         PICW_INCOMPATIBLE_VALUES,
00053         PICW_INVALID_VALUE,
00054         PICW_UNDEFINED_TOKEN,
00055         PICW_UNSUPPORTED_TOKEN
00056       } PIC_WARNING;
00057
00059       typedef enum
00060       {
00061         PICT_INT,
00062         PICT_FLOAT
00063       } PIC_TYPE_ID;
00064
00066       typedef struct
00067       {
00068         size_t  position;
00069         std::string  context;
00070         std::string  token;
00071       } EmptyTokenInfo;
00072
00074       typedef struct
00075       {
00076         size_t        position;
00077         std::string        context;
00078         PIC_TYPE_ID   valueType;
00079         std::string        value0Name;
00080         const void *  value0;
00081         std::string        value1Name;
00082         const void *  value1;
00083       } IncompatibleValueInfo;
00084
00086       typedef struct
00087       {
00088         size_t        position;
00089         std::string        context;
00090         PIC_TYPE_ID   valueType;
00091         std::string        valueName;
00092         const void *  value;
00093       } InvalidValueInfo;
00094
00096       typedef struct
00097       {
00098         size_t        position;
00099         std::string        context;
00100         std::string        token;
00101       } UndefinedTokenInfo;
00102
00104       typedef struct
00105       {
00106         size_t        position;
00107         std::string        expected;
00108         std::string        encountered;
00109       } UnexpectedTokenInfo;
00110
00112       typedef struct
00113       {
00114         size_t        position;
00115         std::string        context;
00116         std::string        token;
00117       } UnknownTokenInfo;
00118
00120       typedef struct
00121       {
00122         size_t        position;
00123         std::string        context;
00124         std::string        token;
00125       } UnsupportedTokenInfo;
00126
00128       typedef struct
00129       {
00130         std::string        file;
00131         unsigned int  systemSpecificErrorCode;
00132       } FileAccessFailedInfo;
00133
00135       typedef struct
00136       {
00137         unsigned int  systemSpecificErrorCode;
00138       } FileMappingFailedInfo;
00139
00141       typedef struct
00142       {
00143         std::string        file;
00144         std::string        context;
00145         unsigned int  expectedVersion;
00146
00147         unsigned int  detectedVersion;
00148
00149       } IncompatibleFileInfo;
00150
00152       typedef struct
00153       {
00154         std::string        file;
00155         std::string        context;
00156       } InvalidFileInfo;
00157
00158     public:
00160       PlugInCallback();
00161
00163       void  setThrowExceptionOnError( bool set );
00164
00166
00171       virtual void onError( PIC_ERROR eid
00172                           , const void *info
00173                           ) const;
00174
00176
00182       virtual bool onWarning( PIC_WARNING wid
00183                             , const void *info
00184                             ) const;
00185
00187
00190       virtual void onUnexpectedEndOfFile( size_t position
00191                                         ) const;
00192
00194
00198       virtual void onUnexpectedToken( size_t position
00199                                     , const std::string &expected
00200                                     , const std::string &encountered
00201                                     ) const;
00202
00204
00208       virtual void onUnknownToken( size_t position
00209                                  , const std::string &context
00210                                  , const std::string &token
00211                                  ) const;
00212
00214
00218       virtual bool onEmptyToken( size_t position
00219                                , const std::string &context
00220                                , const std::string &token
00221                                ) const;
00222
00224
00227       virtual bool onFileEmpty( const std::string &file
00228                               ) const;
00229
00231
00234       virtual bool onFileNotFound( const std::string &file
00235                                  ) const;
00236
00238
00241       virtual bool onFilesNotFound( const std::vector<std::string> &files
00242                                   ) const;
00243
00245
00249       virtual bool onUndefinedToken( size_t position
00250                                    , const std::string &context
00251                                    , const std::string &token
00252                                    ) const;
00253
00255
00259       virtual bool onIncompatibleValues( size_t position
00260                                        , const std::string &context
00261                                        , const std::string &value0Name
00262                                        , int value0
00263                                        , const std::string &value1Name
00264                                        , int value1
00265                                        ) const;
00266
00268
00272       virtual bool onIncompatibleValues( size_t position
00273                                        , const std::string &context
00274                                        , const std::string &value0Name
00275                                        , float value0
00276                                        , const std::string &value1Name
00277                                        , float value1
00278                                        ) const;
00279
00281
00285       virtual bool onInvalidValue( size_t position
00286                                  , const std::string &context
00287                                  , const std::string &valueName
00288                                  , int value
00289                                  ) const;
00290
00292
00296       virtual bool onInvalidValue( size_t position
00297                                  , const std::string &context
00298                                  , const std::string &valueName
00299                                  , float value
00300                                  ) const;
00301
00303
00307       virtual bool onUnsupportedToken( size_t position
00308                                      , const std::string &context
00309                                      , const std::string &token
00310                                      ) const;
00311
00313
00317       virtual void onFileAccessFailed( const std::string& file
00318                                      , unsigned int systemSpecificErrorCode
00319                                      ) const;
00320
00322
00326       virtual void onFileMappingFailed( unsigned int systemSpecificErrorCode
00327                                       ) const;
00328
00330
00334       virtual void onImcompatibleFile( const std::string& file
00335                                      , const std::string& context
00336                                      , unsigned int expectedVersion
00337
00338                                      , unsigned int detectedVersion
00339
00340                                      ) const;
00341
00343
00347       virtual void onInvalidFile( const std::string& file
00348                                 , const std::string& context
00349                                 ) const;
00350
00351     protected:
00353       virtual ~PlugInCallback();
00354
00355     private:
00356       bool  m_throwExceptionOnError;
00357   };
00358
00359   inline  PlugInCallback::PlugInCallback()
00360     : m_throwExceptionOnError(true)
00361   {
00362   }
00363
00364   inline  PlugInCallback::~PlugInCallback()
00365   {
00366   }
00367
00368   inline  void  PlugInCallback::setThrowExceptionOnError( bool set )
00369   {
00370     m_throwExceptionOnError = set;
00371   }
00372
00373   inline  void  PlugInCallback::onError( PIC_ERROR eid, const void *info ) const
00374   {
00375     if ( m_throwExceptionOnError )
00376     {
00377       throw( eid );
00378     }
00379   }
00380
00381   inline  bool  PlugInCallback::onWarning( PIC_WARNING wid, const void *info ) const
00382   {
00383     return( true );
00384   }
00385
00386
00387   inline  void  PlugInCallback::onUnexpectedEndOfFile( size_t position ) const
00388   {
00389     onError( PICE_UNEXPECTED_EOF, &position );
00390   }
00391
00392   inline  void  PlugInCallback::onUnexpectedToken( size_t position, const std::string &expected, const std::string &encountered ) const
00393   {
00394     UnexpectedTokenInfo uti;
00395     uti.position    = position;
00396     uti.expected    = expected;
00397     uti.encountered = encountered;
00398     onError( PICE_UNEXPECTED_TOKEN, &uti );
00399   }
00400
00401   inline  void  PlugInCallback::onUnknownToken( size_t position, const std::string &context, const std::string &token ) const
00402   {
00403     UnknownTokenInfo  uti;
00404     uti.position  = position;
00405     uti.context   = context;
00406     uti.token     = token;
00407     onError( PICE_UNKNOWN_TOKEN, &uti );
00408   }
00409
00410
00411   inline  bool  PlugInCallback::onEmptyToken( size_t position, const std::string &context, const std::string &token ) const
00412   {
00413     EmptyTokenInfo  uti;
00414     uti.position  = position;
00415     uti.context   = context;
00416     uti.token     = token;
00417     return( onWarning( PICW_EMPTY_TOKEN, &uti ) );
00418   }
00419
00420   inline  bool  PlugInCallback::onFileEmpty( const std::string &file ) const
00421   {
00422     return( onWarning( PICW_FILE_EMPTY, &file ) );
00423   }
00424
00425   inline  bool  PlugInCallback::onFileNotFound( const std::string &file ) const
00426   {
00427     return( onWarning( PICW_FILE_NOT_FOUND, &file ) );
00428   }
00429
00430   inline  bool  PlugInCallback::onFilesNotFound( const std::vector<std::string> &files ) const
00431   {
00432     return( onWarning( PICW_FILES_NOT_FOUND, &files ) );
00433   }
00434
00435   inline  bool  PlugInCallback::onUndefinedToken( size_t position, const std::string &context, const std::string &token ) const
00436   {
00437     EmptyTokenInfo  uti;
00438     uti.position  = position;
00439     uti.context   = context;
00440     uti.token     = token;
00441     return( onWarning( PICW_UNDEFINED_TOKEN, &uti ) );
00442   }
00443
00444   inline  bool  PlugInCallback::onIncompatibleValues( size_t position, const std::string &context, const std::string &value0Name,
00445                                                       int value0, const std::string &value1Name, int value1 ) const
00446   {
00447     IncompatibleValueInfo ivi;
00448     ivi.position    = position;
00449     ivi.context     = context;
00450     ivi.valueType   = PICT_INT;
00451     ivi.value0Name  = value0Name;
00452     ivi.value0      = &value0;
00453     ivi.value1Name  = value1Name;
00454     ivi.value1      = &value1;
00455     return( onWarning( PICW_INCOMPATIBLE_VALUES, &ivi ) );
00456   }
00457
00458   inline  bool  PlugInCallback::onIncompatibleValues( size_t position, const std::string &context, const std::string &value0Name,
00459                                                       float value0, const std::string &value1Name, float value1 ) const
00460   {
00461     IncompatibleValueInfo ivi;
00462     ivi.position    = position;
00463     ivi.context     = context;
00464     ivi.valueType   = PICT_FLOAT;
00465     ivi.value0Name  = value0Name;
00466     ivi.value0      = &value0;
00467     ivi.value1Name  = value1Name;
00468     ivi.value1      = &value1;
00469     return( onWarning( PICW_INCOMPATIBLE_VALUES, &ivi ) );
00470   }
00471
00472
00473   inline  bool  PlugInCallback::onInvalidValue( size_t position, const std::string &context,
00474                                                 const std::string &valueName, int value ) const
00475   {
00476     InvalidValueInfo  ivi;
00477     ivi.position  = position;
00478     ivi.context   = context;
00479     ivi.valueName = valueName;
00480     ivi.valueType = PICT_INT;
00481     ivi.value     = &value;
00482     return( onWarning( PICW_INVALID_VALUE, &ivi ) );
00483   }
00484
00485   inline  bool  PlugInCallback::onInvalidValue( size_t position, const std::string &context,
00486                                                 const std::string &valueName, float value ) const
00487   {
00488     InvalidValueInfo  ivi;
00489     ivi.position  = position;
00490     ivi.context   = context;
00491     ivi.valueName = valueName;
00492     ivi.valueType = PICT_FLOAT;
00493     ivi.value     = &value;
00494     return( onWarning( PICW_INVALID_VALUE, &ivi ) );
00495   }
00496
00497   inline  bool  PlugInCallback::onUnsupportedToken( size_t position, const std::string &context, const std::string &token ) const
00498   {
00499     UnsupportedTokenInfo  uti;
00500     uti.position  = position;
00501     uti.context   = context;
00502     uti.token     = token;
00503     return( onWarning( PICW_UNSUPPORTED_TOKEN, &uti ) );
00504   }
00505
00506   inline  void  PlugInCallback::onFileAccessFailed( const std::string& file, unsigned int systemSpecificErrorCode ) const
00507   {
00508     FileAccessFailedInfo fafi;
00509     fafi.file = file;
00510     fafi.systemSpecificErrorCode = systemSpecificErrorCode;
00511     onError(PICE_FILE_ACCESS_FAILED, &fafi);
00512   }
00513
00514   inline  void  PlugInCallback::onFileMappingFailed( unsigned int systemSpecificErrorCode ) const
00515   {
00516     FileMappingFailedInfo fmfi;
00517     fmfi.systemSpecificErrorCode = systemSpecificErrorCode;
00518     onError(PICE_FILE_MAPPING_FAILED, &fmfi);
00519   }
00520
00521   inline  void  PlugInCallback::onImcompatibleFile( const std::string& file, const std::string& context
00522                                                   , unsigned int expectedVersion, unsigned int detectedVersion) const
00523   {
00524     IncompatibleFileInfo ifi;
00525     ifi.file = file;
00526     ifi.context = context;
00527     ifi.expectedVersion = expectedVersion;
00528     ifi.detectedVersion = detectedVersion;
00529     onError(PICE_INCOMPATIBLE_FILE, &ifi);
00530   }
00531
00532   inline  void  PlugInCallback::onInvalidFile( const std::string& file, const std::string& context ) const
00533   {
00534     InvalidFileInfo ifi;
00535     ifi.file = file;
00536     ifi.context = context;
00537     onError(PICE_INVALID_FILE, &ifi);
00538   }
00539 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


PlugInterface.h File Reference

#include "nvsgcommon.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 Fri Aug 4 08:35:05 2006 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
00017 #include "nvutil/PlugIn.h" // general PlugIn class definition
00018
00019 namespace nvsg
00020 {
00021   class Scene;
00022   class TextureImage;
00023   class ViewState;
00024
00026
00092   // SceneLoader interface
00093   class SceneLoader : public nvutil::PlugIn
00094   {
00095     public:
00097
00104       NVSG_API virtual const Scene * load( const std::string& filename
00105                                          , const std::vector<std::string> &searchPaths
00106                                          , const ViewState *& viewState
00108                                          ) = 0;
00109
00110     protected:
00112
00123       NVSG_API virtual ~SceneLoader();
00124   };
00125
00127
00129   class SceneSaver : public nvutil::PlugIn
00130   {
00131     public:
00133
00136       NVSG_API virtual bool save( const Scene &scene, const ViewState *viewState, const std::string& filename ) = 0;
00137
00138     protected:
00140
00151       NVSG_API virtual ~SceneSaver();
00152   };
00153
00155
00156   class TextureLoader : public nvutil::PlugIn
00157   {
00158     public:
00160
00167       NVSG_API virtual const TextureImage * load( const std::string& filename
00168                                      ) = 0;
00169
00170     protected:
00172
00183       NVSG_API virtual ~TextureLoader();
00184   };
00185
00186 } //  namespace nvsg
Generated on Fri Aug 4 08:33:07 2006 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).

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).

Generated on Fri Aug 4 08:35:05 2006 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
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:06 2006 for NVSGSDK by NVIDIA


PointAttribute.h Source File

PointAttribute.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/PrimitiveAttribute.h"
00017 #include <float.h>
00018
00019 namespace nvsg
00020 {
00026   class PointAttribute : public PrimitiveAttribute
00027   {
00028     public:
00032       NVSG_API static const PointAttribute * create();
00033
00041       NVSG_API static const PointAttribute * createFromBase( const PrimitiveAttribute &rhs );
00042
00046       NVSG_API virtual const PointAttribute * clone() const;
00047
00054       NVSG_API bool isAntiAliased() const;
00055
00062       NVSG_API void setAntiAliasing( bool aa );
00063
00068       NVSG_API float getSize() const;
00069
00074       NVSG_API void setSize( float size );
00075
00082       NVSG_API PointAttribute & operator=(const PointAttribute & rhs);
00083
00093       NVSG_API virtual bool isEquivalent( const Object * p
00094                                         , bool ignoreNames
00095                                         , bool deepCompare ) const;
00096
00097     protected:
00101       NVSG_API PointAttribute();
00102
00109       NVSG_API explicit PointAttribute( const PrimitiveAttribute &rhs );
00110
00115       NVSG_API PointAttribute( const PointAttribute &rhs );
00116
00121       NVSG_API virtual ~PointAttribute();
00122
00123     private:
00124       bool  m_antiAliasing;
00125       float m_size;
00126   };
00127
00128   inline float PointAttribute::getSize() const
00129   {
00130     return( m_size );
00131   }
00132
00133   inline bool PointAttribute::isAntiAliased() const
00134   {
00135     return( m_antiAliasing );
00136   }
00137
00138   inline void PointAttribute::setAntiAliasing( bool aa )
00139   {
00140     m_antiAliasing = aa;
00141     increaseIncarnation();
00142   }
00143
00144   inline void PointAttribute::setSize( float size )
00145   {
00146     NVSG_ASSERT( FLT_EPSILON < size );
00147     m_size = size;
00148     increaseIncarnation();
00149   }
00150
00151 } // namespace nvsg
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:07 2006 for NVSGSDK by NVIDIA


PointLight.h Source File

PointLight.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/LightSource.h"
00017
00018 namespace nvsg
00019 {
00033   class PointLight : public LightSource
00034   {
00035     public:
00040       NVSG_API static const PointLight * create();
00041
00049       NVSG_API static const PointLight * createFromBase( const LightSource &rhs );
00050
00054       NVSG_API virtual const PointLight * clone() const;
00055
00060       NVSG_API const nvmath::Vec3f & getPosition() const;
00061
00066       NVSG_API void setPosition( const nvmath::Vec3f & position );
00067
00074       NVSG_API bool isAttenuated() const;
00075
00086       NVSG_API void getAttenuation( float &c
00087                                   , float &l
00088                                   , float &q ) const;
00089
00099       NVSG_API const nvmath::Vec3f& getAttenuation() const;
00100
00111       NVSG_API void setAttenuation( float c
00112                                   , float l
00113                                   , float q );
00114
00124       NVSG_API void setAttenuation( const nvmath::Vec3f &attenuation );
00125
00132       NVSG_API PointLight & operator=( const PointLight & rhs );
00133
00144       NVSG_API virtual bool isEquivalent( const Object * p
00145                                         , bool ignoreNames
00146                                         , bool deepCompare ) const;
00147
00148     protected:
00151       NVSG_API PointLight();
00152
00158       NVSG_API explicit PointLight( const LightSource &rhs );
00159
00163       NVSG_API PointLight( const PointLight &rhs );
00164
00169       NVSG_API virtual ~PointLight();
00170
00171     private:
00172       nvmath::Vec3f m_attenuation;
00173   };
00174
00175   inline void PointLight::getAttenuation( float &c, float &l, float &q ) const
00176   {
00177     NVSG_TRACE();
00178     c = m_attenuation[0];
00179     l = m_attenuation[1];
00180     q = m_attenuation[2];
00181   }
00182
00183   inline const nvmath::Vec3f& PointLight::getAttenuation() const
00184   {
00185     NVSG_TRACE();
00186     return m_attenuation;
00187   }
00188
00189   inline bool PointLight::isAttenuated() const
00190   {
00191     NVSG_TRACE();
00192     return(   ( m_attenuation[0] != 1.0f )
00193           ||  ( m_attenuation[1] != 0.0f )
00194           ||  ( m_attenuation[2] != 0.0f )
00195           );
00196   }
00197
00198   inline void PointLight::setAttenuation( float c, float l, float q )
00199   {
00200     NVSG_TRACE();
00201     m_attenuation[0] = c;
00202     m_attenuation[1] = l;
00203     m_attenuation[2] = q;
00204     increaseIncarnation();
00205   }
00206
00207   inline void PointLight::setAttenuation( const nvmath::Vec3f & attenuation )
00208   {
00209     NVSG_TRACE();
00210     m_attenuation = attenuation;
00211     increaseIncarnation();
00212   }
00213
00214   inline const nvmath::Vec3f & PointLight::getPosition() const
00215   {
00216     NVSG_TRACE();
00217     return m_trafo.getTranslation();
00218   }
00219
00220   inline void PointLight::setPosition( const nvmath::Vec3f & position )
00221   {
00222     NVSG_TRACE();
00223     m_trafo.setTranslation(position);
00224     increaseIncarnation();
00225   }
00226
00227 } //  namespace nvsg
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:08 2006 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"
00017
00018 namespace nvsg
00019 {
00026   class Points : public IndependentPrimitiveSet
00027   {
00028     public:
00032       NVSG_API static const Points * create();
00033
00041       NVSG_API static const Points * createFromBase( const IndependentPrimitiveSet &rhs );
00042
00050       NVSG_API static const Points * createFromBase( const PrimitiveSet &rhs );
00051
00055       NVSG_API virtual const Points * clone() const;
00056
00062       NVSG_API Points & operator=(const Points & rhs);
00063
00064     protected:
00067       NVSG_API Points();
00068
00075       NVSG_API explicit Points( const IndependentPrimitiveSet &rhs );
00076
00082       NVSG_API explicit Points( const PrimitiveSet &rhs );
00083
00087       NVSG_API Points( const Points &rhs );
00088
00093       NVSG_API virtual ~Points();
00094   };
00095
00096 }
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:09 2006 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     protected:
00030       NVSG_API PrimitiveAttribute();
00031
00035       NVSG_API PrimitiveAttribute( const PrimitiveAttribute& rhs );
00036
00039       NVSG_API virtual ~PrimitiveAttribute();
00040
00046       NVSG_API PrimitiveAttribute & operator=(const PrimitiveAttribute & rhs);
00047   };
00048 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


PrimitiveSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Drawable.h"
#include "nvsg/HighlightObject.h"
#include "nvsg/VertexAttributeSet.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 Fri Aug 4 08:35:11 2006 for NVSGSDK by NVIDIA


PrimitiveSet.h Source File

PrimitiveSet.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/HighlightObject.h"
00018 #include "nvsg/VertexAttributeSet.h"
00019
00020 namespace nvsg
00021 {
00027   class PrimitiveSet : public Drawable
00028   {
00029     public:
00033       NVSG_API const VertexAttributeSet * getVertexAttributeSet() const;
00034
00040       NVSG_API void setVertexAttributeSet( const VertexAttributeSet * set );
00041
00051       NVSG_API bool isCompatible( const PrimitiveSet *p
00052                                 , bool ignoreNames = true ) const;
00053
00066       NVSG_API virtual bool isEquivalent( const Object * p
00067                                         , bool ignoreNames
00068                                         , bool deepCompare ) const;
00069
00073       NVSG_API virtual const PrimitiveSet * clone() const = 0;
00074
00075     protected:
00079       NVSG_API PrimitiveSet();
00080
00085       NVSG_API PrimitiveSet( const PrimitiveSet& rhs );
00086
00090       NVSG_API virtual ~PrimitiveSet();
00091
00097       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00098
00105       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00106
00112       NVSG_API PrimitiveSet & operator=( const PrimitiveSet & rhs );
00113
00114     private:
00115       const VertexAttributeSet * m_vertexAttributeSet;
00116   };
00117
00118   inline const VertexAttributeSet * PrimitiveSet::getVertexAttributeSet() const
00119   {
00120     NVSG_TRACE();
00121     return( m_vertexAttributeSet );
00122   }
00123
00124 } //  namespace nvsg
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:11 2006 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 }
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:35:13 2006 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:
00032       NVSG_API static const QuadMeshes * create();
00033
00041       NVSG_API static const QuadMeshes * createFromBase( const MeshedPrimitiveSet &rhs );
00042
00046       NVSG_API virtual const QuadMeshes * clone() const;
00047
00052       NVSG_API QuadMeshes & operator=( const QuadMeshes & rhs );
00053
00054     protected:
00057       NVSG_API QuadMeshes();
00058
00065       NVSG_API QuadMeshes( const MeshedPrimitiveSet &rhs );
00066
00070       NVSG_API QuadMeshes( const QuadMeshes &rhs );
00071
00076       NVSG_API virtual ~QuadMeshes();
00077   };
00078
00089   NVSG_API void calculateTangentSpace( const QuadMeshes * qm
00090                                      , size_t tu = 0
00091                                      , size_t tg = 1
00092                                      , size_t bn = 2 );
00093
00098   NVSG_API void generateNormals( const QuadMeshes * qm );
00099
00100 }
Generated on Fri Aug 4 08:33:07 2006 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

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 Fri Aug 4 08:35:14 2006 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:
00033       NVSG_API static const Quads * create();
00034
00042       NVSG_API static const Quads * createFromBase( const IndependentPrimitiveSet &rhs );
00043
00051       NVSG_API static const Quads * createFromBase( const PrimitiveSet &rhs );
00052
00056       NVSG_API virtual const Quads * clone() const;
00057
00062       NVSG_API bool hasFaces() const;
00063
00068       NVSG_API size_t getNumberOfFaces() const;
00069
00074       NVSG_API const Face4 * getFaces() const;
00075
00084       NVSG_API void setFaces( const Face4 * faces
00085                             , size_t numFaces );
00086
00102       NVSG_API void setFaces( size_t pos
00103                             , const Face4 * faces
00104                             , size_t numFaces );
00105
00111       NVSG_API Quads & operator=( const Quads & rhs );
00112
00113     protected:
00116       NVSG_API Quads();
00117
00124       NVSG_API Quads( const IndependentPrimitiveSet &rhs );
00125
00131       NVSG_API Quads( const PrimitiveSet &rhs );
00132
00136       NVSG_API Quads( const Quads &rhs );
00137
00142       NVSG_API virtual ~Quads();
00143   };
00144
00154   NVSG_API void calculateTangentSpace( const Quads * q
00155                                      , size_t tu = 0
00156                                      , size_t tg = 1
00157                                      , size_t bn = 2 );
00158
00163   NVSG_API void generateNormals( const Quads * q );
00164
00165   // - - - - - - - - - - - - - - - - - - - - - - - - -
00166   // inlines
00167   // - - - - - - - - - - - - - - - - - - - - - - - - -
00168
00169   inline bool Quads::hasFaces() const
00170   {
00171     NVSG_TRACE();
00172     return( 4 <= getNumberOfIndices() );
00173   }
00174
00175   inline size_t Quads::getNumberOfFaces() const
00176   {
00177     NVSG_TRACE();
00178     return( getNumberOfIndices() / 4 );
00179   }
00180
00181   inline const Face4 * Quads::getFaces() const
00182   {
00183     NVSG_TRACE();
00184     return( (const Face4 *) getIndices() );
00185   }
00186
00187   inline void Quads::setFaces( const Face4 * pFaces, size_t numFaces )
00188   {
00189     NVSG_TRACE();
00190     setIndices( (const unsigned int *) pFaces, 4 * numFaces );
00191   }
00192
00193   inline void Quads::setFaces( size_t pos, const Face4* pFaces, size_t numFaces )
00194   {
00195     NVSG_TRACE();
00196     if ( (size_t)-1 != pos )
00197     {
00198       pos *= 4;
00199     }
00200     setIndices( pos, (const unsigned int *) pFaces, 4 * numFaces );
00201   }
00202 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


QuadStrips.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/StrippedPrimitiveSet.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 Fri Aug 4 08:35:15 2006 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/nvsg.h"
00017 #include "nvsg/StrippedPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00038   class QuadStrips : public StrippedPrimitiveSet
00039   {
00040     public:
00044       NVSG_API static const QuadStrips * create();
00045
00053       NVSG_API static const QuadStrips * createFromBase( const StrippedPrimitiveSet &rhs );
00054
00058       NVSG_API virtual const QuadStrips * clone() const;
00059
00064       NVSG_API QuadStrips & operator=(const QuadStrips & rhs);
00065
00066     protected:
00069       NVSG_API QuadStrips();
00070
00077       NVSG_API QuadStrips( const StrippedPrimitiveSet &rhs );
00078
00082       NVSG_API QuadStrips( const QuadStrips &rhs );
00083
00088       NVSG_API virtual ~QuadStrips();
00089   };
00090
00099   NVSG_API void calculateTangentSpace( const QuadStrips * qs
00100                                      , size_t tu = 0
00101                                      , size_t tg = 1
00102                                      , size_t bn = 2 );
00103
00108   NVSG_API void generateNormals( const QuadStrips * q );
00109
00110 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


Quatf.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvmath/Vec4f.h"
#include "nvmath/Vec3f.h"
#include "nvmath/Mat33f.h"

Include dependency graph for Quatf.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 Fri Aug 4 08:35:17 2006 for NVSGSDK by NVIDIA


Quatf.h Source File

Quatf.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 "nvmath/nvmath.h"
00018 #include "nvmath/Vec4f.h"
00019 #include "nvmath/Vec3f.h"
00020 #include "nvmath/Mat33f.h"
00021
00022 namespace nvmath
00023 {
00025
00030   class Quatf
00031   {
00032     public:
00034
00035       NVSG_API Quatf( void );
00036
00038
00040       NVSG_API Quatf( const Vec4f& v
00041                     );
00042
00044
00049       NVSG_API Quatf( float x
00050                     , float y
00051                     , float z
00052                     , float w
00053                     );
00054
00056
00057       NVSG_API Quatf( const Vec3f& axis
00058                     , float angle
00059                     );
00060
00062
00063       NVSG_API Quatf( const Vec3f& vec0
00064                     , const Vec3f& vec1
00065                     );
00066
00068
00069       NVSG_API Quatf( const Mat33f &rot
00070                     );
00071
00073
00074       NVSG_API float& operator[]( size_t i
00075                                 );
00076
00078
00079       NVSG_API const float& operator[]( size_t i
00080                                       ) const;
00081
00083
00084       NVSG_API Quatf& operator=( const Quatf& q
00085                                );
00086
00088
00092       NVSG_API bool operator==( const Quatf& q
00093                               ) const;
00094
00096
00100       NVSG_API bool operator!=( const Quatf& q
00101                               ) const;
00102
00104
00106       NVSG_API const Quatf operator-( void ) const;
00107
00109
00112       NVSG_API Quatf& operator*=( const Quatf& q
00113                                 );
00114
00116
00119       NVSG_API const Quatf operator*( const Quatf& q
00120                                     ) const;
00121
00123
00125       NVSG_API const Vec3f operator*( const Vec3f &v
00126                                     ) const;
00127
00129
00133       NVSG_API Quatf& operator/=( const Quatf& q
00134                                 );
00135
00137
00141       NVSG_API const Quatf operator/( const Quatf& q
00142                                     ) const;
00143
00145
00147       NVSG_API const Quatf operator~( void ) const;
00148
00150
00154       NVSG_API Quatf& normalize( void );
00155
00156     private:
00157       float m_quat[4];
00158   };
00159
00160   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00161   // non-member functions
00162   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00166   inline  void  decompose( const Quatf &q
00167                          , Vec3f &axis
00168                          , float &angle
00169                          )
00170   {
00171     angle = 2.0f * acosf( q[3] );
00172     if ( angle < FLT_EPSILON )
00173     {
00174       //  no angle to rotate about => take just any one
00175       axis[0] = 0.0f;
00176       axis[1] = 0.0f;
00177       axis[2] = 1.0f;
00178     }
00179     else
00180     {
00181       float dummy = 1.0f / sinf( 0.5f * angle );
00182       axis[0] = q[0] * dummy;
00183       axis[1] = q[1] * dummy;
00184       axis[2] = q[2] * dummy;
00185       axis.normalize();
00186     }
00187   }
00188
00192   inline float distance( const Quatf &q0
00193                        , const Quatf &q1
00194                        )
00195   {
00196     return( sqrtf( square( q0[0] - q1[0] ) + square( q0[1] - q1[1] ) + square( q0[2] - q1[2] ) + square( q0[3] - q1[3] ) ) );
00197   }
00198
00203   inline float magnitude( const Quatf &q
00204                         )
00205   {
00206     return( sqrtf( square( q[0] ) + square( q[1] ) + square( q[2] ) + square( q[3] ) ) );
00207   }
00208
00213   inline bool isNormalized( const Quatf &q
00214                           , float epsilon = FLT_EPSILON
00215                           )
00216   {
00217     return( fabsf( magnitude( q ) - 1.0f ) <= 2*epsilon );
00218   }
00219
00224   inline bool isNull( const Quatf &q
00225                     , float epsilon = FLT_EPSILON
00226                     )
00227   {
00228     return( magnitude( q ) <= epsilon );
00229   }
00230
00234   template<>
00235   NVSG_API Quatf lerp<Quatf>( float alpha
00236                             , const Quatf &q0
00237                             , const Quatf &q1
00238                             );
00239
00240   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00241   // inlines
00242   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00243   inline Quatf::Quatf( void )
00244   {
00245   }
00246
00247   inline Quatf::Quatf( float f0, float f1, float f2, float f3 )
00248   {
00249     m_quat[0] = f0;
00250     m_quat[1] = f1;
00251     m_quat[2] = f2;
00252     m_quat[3] = f3;
00253   }
00254
00255   inline Quatf::Quatf( const Vec4f& v )
00256   {
00257     m_quat[0] = v[0];
00258     m_quat[1] = v[1];
00259     m_quat[2] = v[2];
00260     m_quat[3] = v[3];
00261     NVSG_ASSERT( isNormalized( *this ) );
00262   }
00263
00264   inline float& Quatf::operator[]( size_t i )
00265   {
00266     NVSG_ASSERT( 0 <= i && i <= 3 );
00267     return( m_quat[i] );
00268   }
00269
00270   inline const float& Quatf::operator[]( size_t i ) const
00271   {
00272     NVSG_ASSERT( 0 <= i && i <= 3 );
00273     return( m_quat[i] );
00274   }
00275
00276   inline Quatf& Quatf::operator=( const Quatf& q )
00277   {
00278     m_quat[0] = q[0];
00279     m_quat[1] = q[1];
00280     m_quat[2] = q[2];
00281     m_quat[3] = q[3];
00282     return( *this );
00283   }
00284
00285   inline bool Quatf::operator==( const Quatf& q ) const
00286   {
00287     return(     ( fabsf( m_quat[0] - q[0] ) < FLT_EPSILON )
00288             &&  ( fabsf( m_quat[1] - q[1] ) < FLT_EPSILON )
00289             &&  ( fabsf( m_quat[2] - q[2] ) < FLT_EPSILON )
00290             &&  ( fabsf( m_quat[3] - q[3] ) < FLT_EPSILON ) );
00291   }
00292
00293   inline bool Quatf::operator!=( const Quatf& q ) const
00294   {
00295     return(     m_quat[0] != q[0]
00296             ||  m_quat[1] != q[1]
00297             ||  m_quat[2] != q[2]
00298             ||  m_quat[3] != q[3]
00299           );
00300   }
00301
00302   inline const Quatf Quatf::operator-( void ) const
00303   {
00304     return( Quatf( m_quat[0], m_quat[1], m_quat[2], -m_quat[3] ) );
00305   }
00306
00307   inline Quatf& Quatf::operator*=( const Quatf & q )
00308   {
00309     NVSG_ASSERT( isNormalized( *this, FLT_EPSILON ) );
00310     NVSG_ASSERT( isNormalized( q, FLT_EPSILON ) );
00311     *this = Quatf( m_quat[1]*q[2] - m_quat[2]*q[1] + m_quat[3]*q[0] + m_quat[0]*q[3],
00312                    m_quat[2]*q[0] - m_quat[0]*q[2] + m_quat[3]*q[1] + m_quat[1]*q[3],
00313                    m_quat[0]*q[1] - m_quat[1]*q[0] + m_quat[3]*q[2] + m_quat[2]*q[3],
00314                    m_quat[3]*q[3] - m_quat[0]*q[0] - m_quat[1]*q[1] - m_quat[2]*q[2] );
00315     normalize();
00316     return( *this );
00317   }
00318
00319   inline const Quatf Quatf::operator*( const Quatf & q ) const
00320   {
00321     NVSG_ASSERT( isNormalized( *this, FLT_EPSILON ) );
00322     NVSG_ASSERT( isNormalized( q, FLT_EPSILON ) );
00323     Quatf r(*this);
00324     r *= q;
00325     NVSG_ASSERT( isNormalized( r ) );
00326     return( r );
00327   }
00328
00329   inline const Vec3f Quatf::operator*( const Vec3f &v ) const
00330   {
00331     return( Mat33f(*this) * v );
00332   }
00333
00334   inline Quatf& Quatf::operator/=( const Quatf & q )
00335   {
00336     Quatf tmp = *this / q;
00337     *this = tmp;
00338     return( *this );
00339   }
00340
00341   inline const Quatf Quatf::operator/( const Quatf & q ) const
00342   {
00343     NVSG_ASSERT( isNormalized( q ) );
00344     return( *this * ~q /*/ magnitude( q )*/ );
00345   }
00346
00347   inline const Quatf Quatf::operator~( void ) const
00348   {
00349     return( Quatf( -m_quat[0], -m_quat[1], -m_quat[2], m_quat[3] ) );
00350   }
00351 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


RayIntersectTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Plane3f.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 Fri Aug 4 08:35:17 2006 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 "nvmath/Plane3f.h"
00017 #include "nvsg/Drawable.h"
00018 #include "nvsg/Path.h"
00019 #include "nvtraverser/ModelViewTraverser.h"
00020
00021 namespace nvsg
00022 {
00023   class Camera;
00024 }
00025
00026 namespace nvtraverser
00027 {
00029
00033   class Intersection
00034   {
00035     public:
00037
00039       NVSG_API Intersection( const nvsg::Path * pPath
00040                            , const nvsg::Drawable * pDrawable
00041                            , const nvmath::Vec3f & isp
00042                            , float dist
00043                            , size_t primitiveIndex
00044                            , const std::vector<unsigned int> & vertexIndices
00045                            );
00046
00048
00049       NVSG_API Intersection( const Intersection & rhs
00050                            );
00051
00053       NVSG_API virtual ~Intersection(void);
00054
00056       NVSG_API Intersection & operator = (const Intersection & rhs);
00057
00059
00060       NVSG_API const nvsg::Path * getPath() const;
00061
00063
00064       NVSG_API const nvsg::Drawable * getDrawable() const;
00065
00067
00068       NVSG_API const nvmath::Vec3f & getIsp() const;
00069
00071
00072       NVSG_API float getDist() const;
00073
00079       NVSG_API size_t getPrimitiveIndex() const;
00080
00103       NVSG_API const std::vector<unsigned int> & getVertexIndices() const;
00104
00105     protected:
00107
00108       Intersection(void){};
00109
00111
00112       NVSG_API void clone( const Intersection & rhs
00113                          );
00114
00115       const nvsg::Drawable  *     m_pDrawable;
00116       const nvsg::Path      *     m_pPath;
00117       nvmath::Vec3f               m_isp;
00118       float                       m_dist;
00119       size_t                      m_primitiveIndex;
00120       std::vector<unsigned int>   m_vertexIndices;
00121
00122   };
00123
00124   inline Intersection::~Intersection(void)
00125   {
00126     if (m_pDrawable)
00127     {
00128       m_pDrawable->removeRef();
00129       m_pDrawable = NULL;
00130     }
00131
00132     if (m_pPath)
00133     {
00134       m_pPath->removeRef();
00135       m_pPath = NULL;
00136     }
00137   }
00138
00139   inline Intersection::Intersection ( const nvsg::Path * pPath
00140                                     , const nvsg::Drawable * pDrawable
00141                                     , const nvmath::Vec3f & isp
00142                                     , float dist
00143                                     , size_t primitiveIndex
00144                                     , const std::vector<unsigned int> & vertexIndices)
00145   {
00146     NVSG_ASSERT(pDrawable);
00147     NVSG_ASSERT(pPath);
00148
00149     m_isp       = isp;
00150     m_dist      = dist;
00151
00152     m_pDrawable = pDrawable;
00153     m_pDrawable->addRef();
00154
00155     m_pPath     = pPath;
00156     m_pPath->addRef();
00157
00158     m_primitiveIndex = primitiveIndex;
00159
00160     m_vertexIndices = vertexIndices;
00161   }
00162
00163   inline Intersection::Intersection (const Intersection & rhs)
00164   {
00165     clone(rhs);
00166   }
00167
00168   inline Intersection & Intersection::operator = (const Intersection & rhs)
00169   {
00170     clone(rhs);
00171     return (*this);
00172   }
00173
00174   inline void Intersection::clone(const Intersection & rhs)
00175   {
00176     m_isp       = rhs.m_isp;
00177     m_dist      = rhs.m_dist;
00178
00179     m_pDrawable = rhs.m_pDrawable;
00180     m_pDrawable->addRef();
00181
00182     m_pPath     = rhs.m_pPath;
00183     m_pPath->addRef();
00184
00185     m_primitiveIndex = rhs.m_primitiveIndex;
00186
00187     m_vertexIndices = rhs.m_vertexIndices;
00188   }
00189
00190   inline const nvmath::Vec3f & Intersection::getIsp() const
00191   {
00192   return m_isp;
00193   }
00194
00195   inline float Intersection::getDist() const
00196   {
00197     return m_dist;
00198   }
00199
00200   inline const nvsg::Drawable * Intersection::getDrawable() const
00201   {
00202     return m_pDrawable;
00203   }
00204
00205   inline const nvsg::Path * Intersection::getPath() const
00206   {
00207     return m_pPath;
00208   }
00209
00210   inline size_t Intersection::getPrimitiveIndex() const
00211   {
00212     return m_primitiveIndex;
00213   }
00214
00215   inline const std::vector<unsigned int> & Intersection::getVertexIndices() const
00216   {
00217     return m_vertexIndices;
00218   }
00219
00221
00228   class RayIntersectTraverser : public ModelViewTraverser
00229   {
00230     public:
00232       NVSG_API RayIntersectTraverser(void);
00233
00235
00237       NVSG_API void release();
00238
00240
00242       NVSG_API void setRay( const nvmath::Vec3f &origin
00243                           , const nvmath::Vec3f &dir
00244                           );
00245
00247
00249       NVSG_API void setCamClipping( bool b
00250                                   );
00251
00253
00254       NVSG_API const Intersection & getNearest( void ) const;
00255
00257
00258       NVSG_API const Intersection * getIntersections( void ) const;
00259
00261
00262       NVSG_API size_t getNumberOfIntersections( void ) const;
00263
00265
00266       NVSG_API void setViewportSize( size_t width, size_t height );
00267
00268
00269     protected:
00271       NVSG_API virtual ~RayIntersectTraverser(void);
00272
00274
00276       NVSG_API virtual void  doApply( const nvsg::Scene * scene
00277                                     );
00278
00279       // Nodes in the tree:
00280       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode *p );
00281
00282       // Groups in the tree:
00283       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p );
00284       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p);
00285       NVSG_API virtual void handleGroup( const nvsg::Group * p);
00286       NVSG_API virtual void handleLOD( const nvsg::LOD * p);
00287       NVSG_API virtual void handleSwitch( const nvsg::Switch * p);
00288       NVSG_API virtual void handleTransform( const nvsg::Transform * p);
00289
00290       // Other operators:
00291       NVSG_API virtual void handleAnimatedQuads( const nvsg::AnimatedQuads *p );
00292       NVSG_API virtual void handleAnimatedTriangles( const nvsg::AnimatedTriangles *p );
00293       NVSG_API virtual void handleLines( const nvsg::Lines *p );
00294       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips *p );
00295       NVSG_API virtual void handlePoints( const nvsg::Points *p );
00296       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes *p );
00297       NVSG_API virtual void handleQuads( const nvsg::Quads *p );
00298       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips *p );
00299       NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles *p );
00300       NVSG_API virtual void handleTriangles( const nvsg::Triangles *p );
00301       NVSG_API virtual void handleTriFans( const nvsg::TriFans *p );
00302       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips *p );
00303
00304       // Specialized state handling
00305       // overriding handleFaceAttribute and handleCgFx lets us evaluate
00306       // if back-face culling is disabled for subsequent geometry.
00307       // Note, that we consider back-face culling for picking!
00308       NVSG_API virtual void handleFaceAttribute( const nvsg::FaceAttribute *p );
00309       NVSG_API virtual void handleCgFx( const nvsg::CgFx * p );
00310       NVSG_API virtual void handleStateSet( const nvsg::StateSet *p );
00311
00316       NVSG_API virtual bool preTraverseGroup( const nvsg::Group *p );
00317
00322       NVSG_API virtual void postTraverseGroup( const nvsg::Group *p );
00323
00325
00327       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00328                                                 );
00329
00331
00332       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00333                                                  );
00334
00338       NVSG_API bool checkClipPlanes( const nvmath::Vec3f & p );
00339
00344       NVSG_API bool checkClipPlanes( const nvmath::Sphere3f & p );
00345
00347
00352       enum ISType { _NONE = 0
00353                   , _BSTANGENT
00354                   , _BSNEAR
00355                   , _BSFAR
00356                   , _BSNEARFAR
00357                   };
00358
00360
00361       NVSG_API bool checkIntersection( const nvmath::Sphere3f &sphere );
00362
00364
00365       NVSG_API bool RayIntersectTraverser::getWorldIntersection( nvmath::Vec3f &isp
00366                                                                , float &dist
00367                                                                );
00368
00370
00374       NVSG_API bool intersectLine( const nvmath::Vec3f & v0
00375                                  , const nvmath::Vec3f & v1
00376                                  , nvmath::Vec3f & isp
00377                                  , float & dist
00378                                  );
00379
00381
00385       NVSG_API bool intersectPoint( const nvmath::Vec3f & v0
00386                                   , nvmath::Vec3f & isp
00387                                   , float & dist
00388                                   );
00389
00391
00395       NVSG_API bool intersectTriangle( const nvmath::Vec3f & v0
00396                                      , const nvmath::Vec3f & v1
00397                                      , const nvmath::Vec3f & v2
00398                                      , nvmath::Vec3f & isp
00399                                      , float & dist
00400                                      );
00401
00403
00404       NVSG_API void storeIntersection( const nvsg::PrimitiveSet *p
00405                                      , const nvmath::Vec3f &isp
00406                                      , float dist
00407                                      , size_t primitiveIndex
00408                                      , const std::vector<unsigned int> & vertexIndices
00409                                      );
00410
00411 #if !defined(NDEBUG)
00412
00413       NVSG_API void dumpIntersectionList();
00414 #endif
00415
00416     private:
00417       bool equal( nvmath::Vec3f v0, nvmath::Vec3f v1 ) const;
00418       bool lookForLineAttribute( const nvsg::StateSet *ss );
00419       bool lookForPointAttribute( const nvsg::StateSet *ss );
00420
00421       static const nvmath::Vec3f _RAY_ORIGIN_DEFAULT;
00422       static const nvmath::Vec3f _RAY_DIRECTION_DEFAULT;
00423
00424       bool                        m_backFaceCulling;
00425       bool                        m_camClipping;
00426       std::stack<std::vector<nvmath::Plane3f> > m_clipPlanes;
00427       nvsg::Path                * m_curPath;
00428       size_t                      m_currentFrame;
00429       const nvsg::Camera        * m_camera;
00430       std::vector<Intersection>   m_intersectionList;
00431       float                       m_lineWidth;
00432       float                       m_lineWidthDefault;
00433       std::stack<nvmath::Vec3f>   m_msRayOrigin;
00434       std::stack<nvmath::Vec3f>   m_msRayDir;
00435       std::stack<nvmath::Vec3f>   m_msCamDir;
00436       size_t                      m_nearestIntIdx;
00437       float                       m_pointSize;
00438       float                       m_pointSizeDefault;
00439       nvmath::Vec3f               m_rayOrigin;
00440       nvmath::Vec3f               m_rayDir;
00441       std::stack<float>           m_scaleFactors;
00442       size_t                      m_viewportHeight;
00443       size_t                      m_viewportWidth;
00444
00445   };
00446
00447   inline void RayIntersectTraverser::setCamClipping(bool flag)
00448   {
00449     m_camClipping = flag;
00450   }
00451
00452   inline size_t RayIntersectTraverser::getNumberOfIntersections() const
00453   {
00454     return m_intersectionList.size();
00455   }
00456
00457   inline const Intersection & RayIntersectTraverser::getNearest() const
00458   {
00459     NVSG_ASSERT(!m_intersectionList.empty());
00460     return m_intersectionList[m_nearestIntIdx];
00461   }
00462
00463   inline const Intersection * RayIntersectTraverser::getIntersections() const
00464   {
00465     NVSG_ASSERT(!m_intersectionList.empty());
00466     return &m_intersectionList[0];
00467   }
00468 }
Generated on Fri Aug 4 08:33:08 2006 for NVSGSDK by NVIDIA


RCObject.h File Reference

#include "nvsgcommon.h"
#include "nvutil/Allocator.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 Fri Aug 4 08:35:19 2006 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
00023 // memory leak detection
00024 #if !defined(NDEBUG)
00025 # ifndef new
00026 #  define new new(__FILE__, __LINE__)
00027 #  define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
00028 # endif
00029 #endif
00030
00031 namespace nvutil
00032 {
00033   class RCObject;
00034
00042   typedef void DestroyCallback( const RCObject * rcObject, void * data );
00043
00063   class RCObject : public IAllocator
00064   {
00065     public:
00075       NVSG_API void addRef()            const;
00076
00083       NVSG_API void removeRef()         const;
00084
00096       NVSG_API void markUnshareable();
00097
00107       NVSG_API bool isShareable()       const;
00108
00115       NVSG_API bool isShared()          const;
00116
00129       NVSG_API void addOnDestroyCallback( DestroyCallback *dcb, void * data );
00130
00144       NVSG_API void removeOnDestroyCallback( DestroyCallback * dcb, void * data );
00145
00146     protected:
00147
00158       RCObject() : m_refcnt(0), m_shareable(true) {};
00159
00171       RCObject(const RCObject& rhs) : m_refcnt(0), m_shareable(true) {}
00172
00179       RCObject& operator=(const RCObject& rhs) { return *this; }
00180
00187       virtual ~RCObject() {}
00188
00189     private:
00191       mutable int                                       m_refcnt;
00192       bool                                              m_shareable;
00193       std::vector<std::pair<DestroyCallback *,void *> > m_destroyCallbacks;
00194   };
00195
00202   template<typename T>
00203   class RCVector : public std::vector<T>, public RCObject
00204   {
00205     public:
00208       RCVector() {}
00217       explicit RCVector(size_t n) : std::vector<T>(n) {}
00218   };
00219
00229   template <typename T>
00230   class RCPtr
00231   {
00250     template <typename U>
00251     friend void writeAccess(RCPtr<U> &rcPtr);
00252
00253     public:
00260       explicit RCPtr(T* pRCObj=0);
00261
00264       RCPtr(const RCPtr& rhs);
00265
00268       ~RCPtr();
00269
00280       RCPtr<T>& operator=(const RCPtr<T>& rhs);
00281
00289       T* operator->();
00290
00298       const T* operator->() const;
00299
00307       T& operator*();
00308
00316       const T& operator*() const;
00317
00318     private:
00319       void init();                              // initialize a RCPtr<T> object
00320       void clone();                             // deep-copy the embedded object
00321
00322       // the dump pointer
00323       T * m_ptr;
00324   };
00325
00332   template <typename T>
00333   class RCIPtr
00334   {
00353     template <typename U>
00354     friend void writeAccess(RCIPtr<U> &rcPtr);
00355
00356     public:
00363       explicit RCIPtr(T* pRCObj=0);
00364
00367       RCIPtr(const RCIPtr& rhs);
00368
00371       ~RCIPtr();
00372
00383       RCIPtr<T>& operator=(const RCIPtr<T>& rhs);
00384
00392       T* operator->();
00393
00401       const T* operator->() const;
00402
00410       T& operator*();
00411
00419       const T& operator*() const;
00420
00421     private:
00422       // CountHolder acts as an additional indirection and holds
00423       // a dump pointer to the object being reference counted
00424       struct CountHolder : public RCObject
00425       {
00426         // destructor only gets called when the objects
00427         // reference count reaches zero
00428         ~CountHolder() { delete m_ptr; }
00429         T * m_ptr;
00430       };
00431
00432       CountHolder * m_cntHolder;
00433
00434       void init();
00435       void clone(); // copy on write
00436   };
00437
00445   template <typename T>
00446   class RCObject_AutoPtr
00447   {
00448     template<typename U>
00449     friend class RCObject_AutoPtr;
00450
00451     public:
00458       explicit RCObject_AutoPtr(T * ptr=0);
00459
00462       template <typename U>
00463       RCObject_AutoPtr(const RCObject_AutoPtr<U>& rhs);
00464
00471       ~RCObject_AutoPtr();
00472
00479       template <typename U>
00480       RCObject_AutoPtr<T>& operator=(const RCObject_AutoPtr<U>& rhs);
00481
00487       T * get() const;
00488
00496       T * operator->() const;
00497
00505       T&  operator*() const;
00506
00515       T * release();
00516
00524       void reset(T * ptr);
00525
00526     private:
00527       void deletePointer();
00528       T * m_ptr;
00529   };
00530
00539   template<typename T>
00540   class PointerReference
00541   {
00542     public:
00553       PointerReference(T * ptr) : m_ptr(ptr), m_refcnt(1) {}
00554
00556       void addRef() { m_refcnt++; }
00557
00559       void removeRef() { --m_refcnt; }
00560
00566       bool isShared() const { return m_refcnt>1; }
00567
00575       operator T*() const { return m_ptr; }
00576
00584       T* operator->() const { return m_ptr; }
00585
00593       T& operator*() const { return *m_ptr; }
00594
00600       bool operator==(const T* ptr) const { return ptr==m_ptr; }
00601
00607       bool operator!=(const T* ptr) const { return !this->operator==(ptr); }
00608     private:
00609       T * m_ptr;
00610       int m_refcnt;
00611   };
00612
00613   //----------------------------------------------------------------------------
00614   // inline implementations following
00615   //----------------------------------------------------------------------------
00616
00617   inline void RCObject::addRef() const
00618   {
00619     ++m_refcnt;
00620   }
00621
00622   inline void RCObject::removeRef() const
00623   {
00624     NVSG_ASSERT(m_refcnt>0);
00625     if (!--m_refcnt)
00626     {
00627       for ( size_t i=0 ; i<m_destroyCallbacks.size() ; i++ )
00628       {
00629         (*m_destroyCallbacks[i].first)( this, m_destroyCallbacks[i].second );
00630       }
00631       delete this;
00632     }
00633   }
00634
00635   inline void RCObject::markUnshareable()
00636   {
00637     m_shareable=false;
00638   }
00639
00640   inline bool RCObject::isShareable() const
00641   {
00642     return m_shareable==true;
00643   }
00644
00645   inline bool RCObject::isShared() const
00646   {
00647     return m_refcnt>1;
00648   }
00649
00650   inline void RCObject::addOnDestroyCallback( DestroyCallback * dcb, void * data )
00651   {
00652     NVSG_ASSERT( std::find( m_destroyCallbacks.begin(), m_destroyCallbacks.end()
00653                      , std::make_pair( dcb, data ) )
00654                == m_destroyCallbacks.end() );
00655     m_destroyCallbacks.push_back( std::make_pair( dcb, data ) );
00656   }
00657
00658   inline void RCObject::removeOnDestroyCallback( DestroyCallback * dcb, void * data )
00659   {
00660     std::vector<std::pair<DestroyCallback*,void*> >::iterator it;
00661     it = std::find( m_destroyCallbacks.begin(), m_destroyCallbacks.end(), std::make_pair( dcb, data ) );
00662     NVSG_ASSERT( it != m_destroyCallbacks.end() );
00663     m_destroyCallbacks.erase( it );
00664   }
00665
00666   //>>
00667   template <typename T>
00668   inline RCPtr<T>::RCPtr(T* pRCObj)
00669   : m_ptr(pRCObj)
00670   {
00671     init();
00672   }
00673
00674   template <typename T>
00675   inline RCPtr<T>::RCPtr(const RCPtr& rhs)
00676   : m_ptr(rhs.m_ptr)
00677   {
00678     init();
00679   }
00680
00681   template <typename T>
00682   inline RCPtr<T>::~RCPtr()
00683   {
00684     if ( m_ptr )
00685     {
00686       m_ptr->removeRef();
00687     }
00688   }
00689
00690   template <typename T>
00691   inline RCPtr<T>& RCPtr<T>::operator=(const RCPtr<T>& rhs)
00692   {
00693     if ( m_ptr != rhs.m_ptr )
00694     {
00695       // remove reference to former value first
00696       m_ptr->removeRef();
00697       m_ptr = rhs.m_ptr;
00698       init();
00699     }
00700     return *this;
00701   }
00702
00703   template <typename T>
00704   inline T* RCPtr<T>::operator->()
00705   {
00706     return m_ptr;
00707   }
00708
00709   template <typename T>
00710   inline const T* RCPtr<T>::operator->() const
00711   {
00712     return m_ptr;
00713   }
00714
00715   template <typename T>
00716   inline T& RCPtr<T>::operator*()
00717   {
00718     return *m_ptr;
00719   }
00720
00721   template <typename T>
00722   inline const T& RCPtr<T>::operator*() const
00723   {
00724     return *m_ptr;
00725   }
00726
00727   template <typename T>
00728   inline void RCPtr<T>::init()
00729   {
00730     if ( !m_ptr ) return;
00731
00732     if ( !m_ptr->isShareable() )
00733     {
00734       // deep copy required!
00735       m_ptr = new T(*m_ptr);
00736     }
00737     m_ptr->addRef();
00738   }
00739
00740   template <typename T>
00741   inline void RCPtr<T>::clone()
00742   {
00743     if ( m_ptr->isShared() )
00744     {
00745       // need to wedge off an own copy if original data is shared
00746       T * pOldVal = m_ptr; // remember the old object pointer for deep copying below
00747       m_ptr->removeRef(); // unreference the object before beeing new assigned
00748       m_ptr = new T(*pOldVal); // deep copy -> T(const T&) required!
00749       m_ptr->addRef();
00750     }
00751   }
00752   //>>
00753   template <typename T>
00754   inline RCIPtr<T>::RCIPtr(T * pObj)
00755   : m_cntHolder(new CountHolder)
00756   {
00757     m_cntHolder->m_ptr = pObj;
00758     init();
00759   }
00760
00761   template <typename T>
00762   inline RCIPtr<T>::RCIPtr(const RCIPtr<T>& rhs)
00763   : m_cntHolder(rhs.m_cntHolder)
00764   {
00765     init();
00766   }
00767
00768   template <typename T>
00769   inline RCIPtr<T>::~RCIPtr()
00770   {
00771     m_cntHolder->removeRef();
00772   }
00773
00774   template <typename T>
00775   inline RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr<T>& rhs)
00776   {
00777     if ( m_cntHolder != rhs.m_cntHolder )
00778     {
00779       m_cntHolder->removeRef(); // unreference the object before beeing new assigned
00780       m_cntHolder = rhs.m_cntHolder;
00781       init();
00782     }
00783     return *this;
00784   }
00785
00786   template <typename T>
00787   inline const T* RCIPtr<T>::operator->() const
00788   {
00789     // const access, no need for copy on write here
00790     return m_cntHolder->m_ptr;
00791   }
00792
00793   template <typename T>
00794   inline T* RCIPtr<T>::operator->()
00795   {
00796     // perform copy on write with every non-const access to the pointed-to object
00797     // clone();
00798     return m_cntHolder->m_ptr;
00799   }
00800
00801   template <typename T>
00802   inline const T& RCIPtr<T>::operator*() const
00803   {
00804     // const access, no need for copy on write here
00805     return *(m_cntHolder->m_ptr);
00806   }
00807
00808   template <typename T>
00809   inline T& RCIPtr<T>::operator*()
00810   {
00811     // perform copy on write with every non-const access to the pointed-to object
00812     // clone();
00813     return *(m_cntHolder->m_ptr);
00814   }
00815
00816   template <typename T>
00817   inline void RCIPtr<T>::init()
00818   {
00819     if ( !m_cntHolder->isShareable() )
00820     {
00821       // non-shareables must not be shared (refcnt==1)
00822       _ASSERTE(!m_cntHolder->isShared());
00823       // must not unreference unshared objects because this
00824       // would delete the pointed-to object immediately!
00825       T * pOldVal = m_cntHolder->m_ptr;
00826       m_cntHolder = new CountHolder;
00827       m_cntHolder->m_ptr = new T(*pOldVal);
00828     }
00829     m_cntHolder->addRef();
00830   }
00831
00832   template <typename T>
00833   inline void RCIPtr<T>::clone()
00834   {
00835     if ( m_cntHolder->isShared() )
00836     {
00837       T * pOldVal = m_cntHolder->m_ptr; // remember the old object pointer for deep copying below
00838       m_cntHolder->removeRef(); // unreference the object before beeing new assigned
00839       m_cntHolder = new CountHolder;
00840       m_cntHolder->m_ptr = new T(*pOldVal); // deep copy
00841       m_cntHolder->addRef();
00842     }
00843   }
00844   //>>
00845
00846   template <typename T>
00847   inline RCObject_AutoPtr<T>::RCObject_AutoPtr(T * ptr)
00848   : m_ptr(ptr)
00849   {
00850   }
00851
00852   template <typename T>
00853   template <typename U>
00854   inline RCObject_AutoPtr<T>::RCObject_AutoPtr(const RCObject_AutoPtr<U>& rhs)
00855   : m_ptr(rhs.release())
00856   {
00857     // !! don't add reference here !!
00858   }
00859
00860   template <typename T>
00861   inline RCObject_AutoPtr<T>::~RCObject_AutoPtr()
00862   {
00863     deletePointer();
00864   }
00865
00866   template <typename T>
00867   template <typename U>
00868   inline RCObject_AutoPtr<T>& RCObject_AutoPtr<T>::operator=(const RCObject_AutoPtr<U>& rhs)
00869   {
00870     if ( this != &rhs )
00871     {
00872       reset(rhs.release());
00873     }
00874     return *this;
00875   }
00876
00877   template <typename T>
00878   inline T * RCObject_AutoPtr<T>::get() const
00879   {
00880     return m_ptr;
00881   }
00882
00883   template <typename T>
00884   inline T * RCObject_AutoPtr<T>::operator->() const
00885   {
00886     return m_ptr;
00887   }
00888
00889   template <typename T>
00890   inline T&  RCObject_AutoPtr<T>::operator*() const
00891   {
00892     return *m_ptr;
00893   }
00894
00895   template <typename T>
00896   inline T * RCObject_AutoPtr<T>::release()
00897   {
00898     T * ptr = m_ptr;
00899     m_ptr = 0;
00900     return ptr;
00901   }
00902
00903   template <typename T>
00904   void RCObject_AutoPtr<T>::reset(T * ptr)
00905   {
00906     if ( m_ptr != ptr )
00907     {
00908       deletePointer();
00909       m_ptr = ptr;
00910       // !! don't ad reference here !!
00911     }
00912   }
00913
00914   template <typename T>
00915   void RCObject_AutoPtr<T>::deletePointer()
00916   {
00917     if ( m_ptr )
00918     {
00919       m_ptr->addRef();
00920       m_ptr->removeRef();
00921     }
00922   }
00923
00924   //>>
00925   template <typename T>
00926   inline void writeAccess( RCPtr<T> &rcPtr )
00927   {
00928     // perform a deep copy of the embedded object if shared
00929     rcPtr.clone();
00930   }
00931
00932   //>>
00933   template <typename T>
00934   inline void writeAccess( RCIPtr<T> &rcPtr )
00935   {
00936     // perform a deep copy of the embedded object if shared
00937     rcPtr.clone();
00938   }
00939
00940 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
00942
00957   struct addReference
00958   {
00960
00962     template <typename RCOBJPTR>
00963     RCOBJPTR operator()( RCOBJPTR pRCObject
00964                       );
00965
00967
00969     template <typename AnyType, typename RCOBJPTR>
00970       const std::pair<AnyType, RCOBJPTR>& operator()( std::pair<AnyType,RCOBJPTR>& p
00971                                             );
00972   };
00973
00974   template <typename RCOBJPTR>
00975   RCOBJPTR addReference::operator()( RCOBJPTR pRCObject )
00976   {
00977     pRCObject->addRef();
00978     return pRCObject;
00979   }
00980
00981   template <typename AnyType, typename RCOBJPTR>
00982   const std::pair<AnyType, RCOBJPTR>& addReference::operator()( std::pair<AnyType,RCOBJPTR>& p )
00983   {
00984     p.second->addRef();
00985     return p;
00986   }
00987 //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
00988
00990   struct removeReference
00991   {
00993     template <typename RCOBJPTR>
00994     RCOBJPTR operator()(RCOBJPTR pRCObject)
00995       { pRCObject->removeRef(); return pRCObject; }
00996
00998     template <typename AnyType, typename RCOBJPTR>
00999     const std::pair<AnyType, RCOBJPTR>& operator() (std::pair<AnyType,RCOBJPTR>& p)
01000       { p.second->removeRef(); return p; }
01001   };
01002
01003 } // namespace nvutil
01004
01005 #ifdef _DEFINED_DBGNEW
01006 # undef new
01007 #endif
Generated on Fri Aug 4 08:33:08 2006 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 Fri Aug 4 08:35:19 2006 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 Fri Aug 4 08:33:08 2006 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/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 nvui

Detailed Description

Generated on Fri Aug 4 08:35:21 2006 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/ProblemLog.h"
00023
00024 #include <vector>
00025
00026 namespace nvui
00027 {
00037   class RenderArea
00038   {
00039     public:
00043       NVSG_API virtual ~RenderArea();
00044
00056       NVSG_API virtual bool init( RenderArea * shareArea = NULL );
00057
00063       NVSG_API virtual void destroy( void );
00064
00080       NVSG_API virtual void renderScene();
00081
00088       NVSG_API void interruptRender();
00089
00097       NVSG_API bool wasRenderInterrupted() const;
00098
00105       NVSG_API virtual void setViewportSize( size_t width, size_t height );
00106
00110       NVSG_API size_t getViewportHeight() const;
00111
00115       NVSG_API size_t getViewportWidth() const;
00116
00130       NVSG_API bool pickCameraTargetPoint( int x, int y );
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 size_t getNumberOfCullTraverser() const;
00206
00215       NVSG_API nvtraverser::CullTraverser * getCullTraverser(size_t 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( const nvsg::Scene * scene
00285                                 , const nvsg::ViewState * viewState );
00286
00292       NVSG_API const nvsg::ViewState * getViewState() const;
00293
00302       NVSG_API void setViewState( const nvsg::ViewState * viewState );
00303
00309       NVSG_API const nvsg::Scene * getScene() const;
00310
00318       NVSG_API void setScene( const nvsg::Scene * scene );
00319
00333       NVSG_API static size_t 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
00358       enum
00359       { _UNDEFINED    = 0x00000000
00360       , _STEREO       = 0x00000001
00361       , _MULTISAMPLE  = 0x00000002
00362       };
00363
00364       std::vector<nvtraverser::CullTraverser *>  m_cullTraverser;
00366       nvtraverser::RenderTraverser             * m_renderTraverser;
00368       nvtraverser::AppTraverser                * m_appTraverser;
00371       const nvsg::Scene * m_scene;
00372       const nvsg::ViewState * m_viewState;
00375       unsigned long       m_features;
00377       UINT                m_numMSBuffers;
00378       bool                m_raCreated;
00379       size_t              m_raHeight;
00380       size_t              m_raWidth;
00382       static size_t       m_idRenderArea;
00388       nvutil::ProblemLog m_problemLog;
00390     private:
00391       bool m_frameInterrupted; // will be evaluated inside renderScene
00392   };
00393
00394   // - - - - - - - - - - - - - - - - - - - - - - - - - - -
00395   // inlines
00396   // - - - - - - - - - - - - - - - - - - - - - - - - - - -
00397
00398   inline float RenderArea::getAspectRatio() const
00399   {
00400     NVSG_ASSERT( m_raHeight > 0 && m_raWidth > 0 );
00401
00402     if (m_raHeight > 0 && m_raWidth > 0)
00403     {
00404       return( (float) m_raWidth / m_raHeight );
00405     }
00406
00407     return 0.f; // error
00408   }
00409
00410   inline const nvsg::ViewState * RenderArea::getViewState() const
00411   {
00412     return( m_viewState );
00413   }
00414
00415   inline const nvsg::Scene * RenderArea::getScene() const
00416   {
00417     return( m_scene );
00418   }
00419
00420   inline nvtraverser::RenderTraverser * RenderArea::getRenderTraverser() const
00421   {
00422     return( m_renderTraverser );
00423   }
00424
00425   inline void RenderArea::setRenderTraverser( nvtraverser::RenderTraverser * tr )
00426   {
00427     if (m_renderTraverser)
00428     {
00429       m_renderTraverser->removeRef();
00430     }
00431
00432     m_renderTraverser = tr;
00433
00434     if (m_renderTraverser)
00435     {
00436       m_renderTraverser->addRef();
00437     }
00438   }
00439
00440   inline void RenderArea::setAppTraverser(nvtraverser::AppTraverser * tr)
00441   {
00442     if (m_appTraverser)
00443     {
00444       m_appTraverser->removeRef();
00445     }
00446
00447     m_appTraverser = tr;
00448
00449     if (m_appTraverser)
00450     {
00451       m_appTraverser->addRef();
00452     }
00453   }
00454
00455   inline nvtraverser::AppTraverser * RenderArea::getAppTraverser() const
00456   {
00457     return m_appTraverser;
00458   }
00459
00460   inline void RenderArea::pushCullTraverser(nvtraverser::CullTraverser * tr)
00461   {
00462     NVSG_ASSERT(tr);
00463
00464     m_cullTraverser.push_back(tr);
00465     tr->addRef();
00466   }
00467
00468   inline void RenderArea::popCullTraverser()
00469   {
00470     NVSG_ASSERT(!m_cullTraverser.empty());
00471
00472     m_cullTraverser.back()->removeRef();
00473     m_cullTraverser.pop_back();
00474   }
00475
00476   inline size_t RenderArea::getNumberOfCullTraverser() const
00477   {
00478     return m_cullTraverser.size();
00479   }
00480
00481   inline nvtraverser::CullTraverser * RenderArea::getCullTraverser(size_t position) const
00482   {
00483     NVSG_ASSERT(m_cullTraverser.size() > position);
00484
00485     return m_cullTraverser[position];
00486   }
00487
00488   inline size_t RenderArea::createNewRenderAreaID()
00489   {
00490     return (++m_idRenderArea);
00491   }
00492
00493   inline size_t RenderArea::getViewportHeight() const
00494   {
00495     return m_raHeight;
00496   }
00497
00498   inline size_t 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 Fri Aug 4 08:33:08 2006 for NVSGSDK by NVIDIA


RenderTraverser.h File Reference

#include "nvsgcommon.h"
#include "nvtraverser/ModelViewTraverser.h"
#include "nvmath/Plane3f.h"
#include "nvmath/Vec4f.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 "nvutil/Incarnation.h"
#include <list>
#include <algorithm>

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 nvtraverser

Detailed Description

Generated on Fri Aug 4 08:35:24 2006 for NVSGSDK by NVIDIA


RenderTraverser.h Source File

RenderTraverser.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 "nvtraverser/ModelViewTraverser.h"
00018 #include "nvmath/Plane3f.h"
00019 #include "nvmath/Vec4f.h"
00020 #include "nvsg/CgFx.h"
00021 #include "nvsg/DAL.h"
00022 #include "nvsg/FaceAttribute.h"
00023 #include "nvsg/LightSource.h"
00024 #include "nvsg/PrimitiveSet.h"
00025 #include "nvsg/StateAttribute.h"
00026 #include "nvsg/StateSet.h"
00027 #include "nvsg/ViewState.h"
00028 #include "nvutil/Incarnation.h"
00029 #include <list>
00030 #include <algorithm>
00031
00032 namespace nvtraverser
00033 {
00034   // forward declaration of some helper classes used internally only
00035   class RenderElementPool;
00036   class ClipPlanesElement;
00037   class LightsElement;
00038   class TransformElement;
00039   class RenderElement;
00040   class HighlightElement;
00041
00042   // renderer type IDs
00043   enum
00044   {
00045     RT_GL  = 0x00010000
00046   , RT_DX8 = 0x00020000
00047   , RT_DX9 = 0x00040000
00048   };
00049
00050
00052
00063   class RenderTraverser : public ModelViewTraverser
00064   {
00065     public:
00066
00067       enum GeometryCacheTechnique
00068       {
00069         GCT_NONE,
00070         GCT_DL,
00071         GCT_VBO
00072       };
00073
00074       enum JitterTechnique
00075       {
00076         JT_NONE,
00077         JT_READ_PIXELS,
00078         JT_ACCUM,
00079         JT_PBUFFER
00080       };
00081
00082       enum RenderTechnique
00083       {
00084         RT_UNLIT,
00085         RT_SHADED,
00086         RT_TEXTURED,
00087         RT_EFFECTED,
00088       };
00089
00091       enum ShadowTechnique
00092       {
00093         ST_NONE,
00094         ST_SHADOW_MAP
00095       };
00096
00098       enum SortingPolicy
00099       {
00100         SP_NONE,
00101         SP_DEPTH,
00102         SP_STATE
00103       };
00104
00105       enum TransparencyTechnique
00106       {
00107         TT_NONE,
00108         TT_STIPPLED,
00109         TT_BLENDED,
00110         TT_SORTED_BLENDED,
00111         TT_ORDER_INDEPENDENT
00112       };
00113
00114       enum OITTechnique
00115       {
00116         OT_TEXTURE,
00117         OT_PBUFFER
00118       };
00119
00121
00122       NVSG_API bool isCgFxAware( void ) const;
00123
00125       //** \return The currently used geometry caching technique. */
00126       NVSG_API GeometryCacheTechnique getGeometryCacheTechnique( void ) const;
00127
00129
00131       NVSG_API virtual bool isGeometryCacheTechniqueSupported( GeometryCacheTechnique gct
00132                                                               ) const;
00133
00135       NVSG_API virtual void setGeometryCacheTechnique( GeometryCacheTechnique gct
00136                                                       );
00137
00139
00140       NVSG_API JitterTechnique getJitterTechnique( void ) const;
00141
00143
00145       NVSG_API virtual bool isJitterTechniqueSupported( JitterTechnique jt
00146                                                       ) const;
00147
00149       NVSG_API virtual void setJitterTechnique( JitterTechnique jt
00150                                               );
00151
00153
00155       NVSG_API bool isFrontFaceCulling() const;
00156
00158
00160       NVSG_API bool isBackFaceCulling() const;
00161
00163
00165       NVSG_API void setFaceCulling( bool front, bool back );
00166
00168       NVSG_API bool isFaceCullingOverwrite() const;
00169
00171       NVSG_API void setFaceCullingOverwrite( bool overwrite );
00172
00174
00175       NVSG_API nvsg::FaceMode getFaceMode( void ) const;
00176
00178
00179       NVSG_API void setFaceMode( nvsg::FaceMode mode );
00180
00182       NVSG_API bool isFaceModeOverwrite() const;
00183
00185       NVSG_API void setFaceModeOverwrite( bool overwrite );
00186
00188
00189       NVSG_API bool isTwoSidedLigthing() const;
00190
00192
00193       NVSG_API void setTwoSidedLighting( bool enable );
00194
00196       NVSG_API bool isTwoSidedLightingOverwrite() const;
00197
00199       NVSG_API void setTwoSidedLightingOverwrite( bool overwrite );
00200
00202       //** \return The currently used render technique. */
00203       NVSG_API RenderTechnique getRenderTechnique( void ) const;
00204
00206
00208       NVSG_API virtual bool isRenderTechniqueSupported( RenderTechnique rt
00209                                                       ) const;
00210
00212       NVSG_API void setRenderTechnique( RenderTechnique rt
00213                                       );
00214
00216
00217       NVSG_API ShadowTechnique getShadowTechnique( void ) const;
00218
00220
00222       NVSG_API virtual bool isShadowTechniqueSupported( ShadowTechnique st
00223                                                       ) const;
00224
00226
00227       NVSG_API virtual void setShadowTechnique( ShadowTechnique st
00228                                               );
00229
00231
00232       NVSG_API size_t getShadowMapSize( void ) const;
00233
00235
00236       NVSG_API virtual void setShadowMapSize( size_t size
00237                                             );
00238
00240
00243       NVSG_API float getShadowMapIntensity( void ) const;
00244
00246
00249       NVSG_API void setShadowMapIntensity( float intensity );
00250
00252
00254       NVSG_API size_t getTextureSizeLimit( void ) const;
00255
00257
00259       NVSG_API virtual void setTextureSizeLimit( size_t size
00260                                               );
00261
00263       //** \return The currently used transparency technique. */
00264       NVSG_API TransparencyTechnique getTransparencyTechnique( void ) const;
00265
00267
00269       NVSG_API virtual bool isTransparencyTechniqueSupported( TransparencyTechnique tt
00270                                                             ) const;
00271
00273       NVSG_API virtual void setTransparencyTechnique( TransparencyTechnique tt
00274                                                     );
00275
00277       //** \return The currently used OIT technique. */
00278       NVSG_API OITTechnique getOITTechnique( void ) const;
00279
00281
00283       NVSG_API virtual bool isOITTechniqueSupported( OITTechnique ot
00284                                                     ) const;
00285
00287
00288       NVSG_API virtual void setOITTechnique( OITTechnique ot
00289                                             );
00290
00292
00293       NVSG_API size_t getOITMaxPasses( void ) const;
00294
00296       NVSG_API virtual void setOITMaxPasses( size_t maxPasses
00297
00298                                             );
00299
00301
00302       NVSG_API float getOITThreshold( void ) const;
00303
00305
00310       NVSG_API void setOITThreshold( float threshold
00311                                             );
00312
00314       NVSG_API void setLineAntiAliasing( bool onOff
00315                                        );
00316
00318
00319       NVSG_API bool isLineAntiAliasingEnabled( void ) const;
00320
00321
00323
00324       NVSG_API float getLineWidth( void ) const;
00325
00327       NVSG_API void setLineWidth( float width
00328                                 );
00329
00331       NVSG_API void setPointAntiAliasing( bool onOff
00332                                         );
00333
00335
00336       NVSG_API bool isPointAntiAliasingEnabled( void ) const;
00337
00339
00340       NVSG_API float getPointSize( void ) const;
00341
00343       NVSG_API void setPointSize( float size
00344                                 );
00345
00347
00351       NVSG_API void setSortingPolicy( SortingPolicy sp
00352                                     );
00353
00355
00356       NVSG_API SortingPolicy getSortingPolicy( void ) const;
00357
00359
00361       NVSG_API virtual bool isOcclusionCullingSupported( void ) const;
00362
00364       NVSG_API virtual void setOcclusionCulling( bool onOff
00365                                                );
00366
00368
00369       NVSG_API bool isOcclusionCulling( void ) const;
00370
00371     protected:
00373       NVSG_API RenderTraverser(void);
00375       NVSG_API virtual ~RenderTraverser(void);
00376
00378
00383       NVSG_API virtual void doApply( const nvsg::Scene     * scene
00384                                    );
00385
00387       NVSG_API virtual void doRender( const nvsg::Scene * scene ) = 0;
00388
00390
00391       NVSG_API void setCgFxAwareness( bool aware
00392                                     );
00393
00395
00397       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00398
00400
00402       NVSG_API virtual void handleParallelCamera( const nvsg::ParallelCamera * p
00403                                                 , const nvsg::Node * root
00404                                                 );
00405
00407
00409       NVSG_API virtual void handlePerspectiveCamera( const nvsg::PerspectiveCamera * p
00410                                                    , const nvsg::Node * root
00411                                                    );
00412
00414
00416       NVSG_API virtual void handleStateVariant( const nvsg::StateVariant * p
00417                                               );
00418
00420
00422       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00423
00425       NVSG_API virtual bool preTraverseDrawables( const nvsg::GeoNode *p
00426                                                 , size_t i
00427                                                 );
00428
00430       NVSG_API virtual void postTraverseDrawables( const nvsg::GeoNode *p
00431                                                  , size_t i
00432                                                  );
00434
00436       NVSG_API virtual bool preTraverseGroup( const nvsg::Group *p
00437         );
00438
00440
00442       NVSG_API virtual void postTraverseGroup( const nvsg::Group *p
00443                                              );
00444
00446
00448       NVSG_API virtual bool preTraverseTransform( const nvmath::Trafo *p
00449                                                 );
00450
00452
00454       NVSG_API virtual void postTraverseTransform( const nvmath::Trafo *p
00455                                                  );
00456
00458
00460       NVSG_API virtual void traverseLight( const nvsg::LightSource * p
00461                                          );
00462
00464
00467       NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * p
00468                                                 );
00469
00471       NVSG_API virtual void handleMapArray( const nvsg::MapArray * p );
00472
00474       NVSG_API virtual void preTraverseMap( const nvsg::MapArray * p, size_t index );
00475
00477       NVSG_API virtual void handleMapElement( const nvsg::MapElement * p );
00478
00480       NVSG_API virtual void handleMapMatrix( const nvsg::MapMatrix * p );
00481
00483       NVSG_API virtual void preTraverseMap( const nvsg::MapMatrix * p, size_t col, size_t row );
00484
00486       NVSG_API virtual void preTraverseMapColumn( const nvsg::MapMatrix * p, size_t col );
00487
00489       NVSG_API virtual void postTraverseMapColumn( const nvsg::MapMatrix * p, size_t col );
00490
00492
00493       NVSG_API bool isOverlayPass( void ) const;
00494
00496
00497       NVSG_API bool isTransparentPass( void ) const;
00498
00504       NVSG_API virtual void render( const nvsg::Camera * cam );
00505
00507
00508       NVSG_API virtual void renderBegin( void );
00509
00511
00512       NVSG_API virtual void renderEnd( void );
00513
00515
00519       void renderObject( const nvsg::Object* object
00520                        );
00521
00523
00539       template<typename RendererType>
00540         void addObjectRenderer( unsigned int objectCode
00541         , RendererType renderer
00542         );
00543
00545
00550       template <typename T>
00551         void renderObject( const nvsg::Object* object
00552                          , T arg
00553                          );
00554
00556
00557       NVSG_API virtual void renderQuadMeshes( const nvsg::QuadMeshes *p
00558         );
00559
00561
00562       NVSG_API virtual void renderAnimatedQuads( const nvsg::AnimatedQuads *p
00563                                                );
00564
00566
00567       NVSG_API virtual void renderAnimatedTriangles( const nvsg::AnimatedTriangles *p
00568                                                    );
00569
00571
00572       NVSG_API virtual void renderBlendAttribute( const nvsg::BlendAttribute *p
00573                                                 , bool enable
00574                                                 );
00575
00577
00578       NVSG_API virtual void renderCgFx( const nvsg::CgFx *p
00579                                       , bool enable
00580                                       );
00581
00583
00584       NVSG_API virtual void renderDepthAttribute( const nvsg::DepthAttribute *p
00585                                                 , bool enable
00586                                                 );
00587
00589
00590       NVSG_API virtual void renderDirectedLight( const nvsg::DirectedLight *p
00591                                                , bool enable
00592                                                );
00593
00595
00596       NVSG_API virtual void renderFaceAttribute( const nvsg::FaceAttribute *p
00597                                                , bool enable
00598                                                );
00599
00601
00602       NVSG_API virtual void renderHighlightBox( const nvsg::HighlightBox * p
00603                                               );
00604
00606
00607       NVSG_API virtual void renderHighlightEdges( const nvsg::HighlightEdges * p
00608                                                 );
00609
00611
00612       NVSG_API virtual void renderLineAttribute( const nvsg::LineAttribute *p
00613                                                , bool enable
00614                                                );
00615
00617
00618       NVSG_API virtual void renderLines( const nvsg::Lines *p
00619                                        );
00620
00622
00623       NVSG_API virtual void renderLineStrips( const nvsg::LineStrips *p
00624                                             );
00625
00627
00628       NVSG_API virtual void renderPointAttribute( const nvsg::PointAttribute *p
00629                                                 , bool enable
00630                                                 );
00631
00633
00634       NVSG_API virtual void renderPoints( const nvsg::Points *p
00635                                         );
00636
00638
00639       NVSG_API virtual void renderMaterial( const nvsg::Material *p
00640                                           , bool enable
00641                                           );
00642
00644
00645       NVSG_API virtual void renderParallelCamera( const nvsg::ParallelCamera *p
00646                                                 );
00647
00649
00650       NVSG_API virtual void renderPerspectiveCamera( const nvsg::PerspectiveCamera *p
00651                                                    );
00652
00654
00655       NVSG_API virtual void renderPointLight( const nvsg::PointLight *p
00656                                             , bool enable
00657                                             );
00658
00660
00661       NVSG_API virtual void renderQuads( const nvsg::Quads *p
00662                                        );
00663
00665
00666       NVSG_API virtual void renderQuadStrips( const nvsg::QuadStrips *p
00667                                             );
00668
00670
00671       NVSG_API virtual void renderSkinnedTriangles( const nvsg::SkinnedTriangles *p
00672                                                   );
00673
00675
00676       NVSG_API virtual void renderSpotLight( const nvsg::SpotLight *p
00677                                            , bool enable
00678                                            );
00679
00681
00683       NVSG_API virtual void renderStatePass( const nvsg::StatePass *p
00684                                            );
00685
00687
00689       NVSG_API virtual void renderTextureAttribute( const nvsg::TextureAttribute *p
00690                                                   , bool enable
00691                                                   );
00692
00694
00695       NVSG_API virtual void renderTextureAttributeItem( const nvsg::TextureAttributeItem *p
00696                                                       , size_t tu
00697                                                       );
00698
00700
00701       NVSG_API virtual void renderTriangles( const nvsg::Triangles *p
00702                                            );
00703
00705
00706       NVSG_API virtual void renderTriFans( const nvsg::TriFans *p
00707                                          );
00708
00710
00711       NVSG_API virtual void renderTriStrips( const nvsg::TriStrips *p
00712                                            );
00713
00715
00716       NVSG_API virtual void setClipPlane( size_t index
00717                                         , const nvmath::Plane3f & plane
00718                                         , bool enable
00719                                         );
00720
00722
00723       NVSG_API virtual void setTransforms( const nvmath::Mat44f &modelToWorld
00724                                          , const nvmath::Mat44f &worldToModel
00725                                          , bool needsNormalize
00726                                          , bool needsMirror
00727                                          );
00728
00730       NVSG_API virtual void overlayBegin( void );
00731
00733       NVSG_API virtual void overlayEnd( void );
00734
00736       NVSG_API virtual void transparentBegin( void );
00737
00739       NVSG_API virtual void transparentEnd( void );
00740
00742       NVSG_API virtual void highlightBegin( void );
00743
00745       NVSG_API virtual void highlightEnd( void );
00746
00748       NVSG_API virtual void primitiveSetsBegin();
00749
00751
00752       NVSG_API virtual bool primitiveSetsEnd();
00753
00755
00757       NVSG_API const nvsg::CgFx * getCurrentCgFx( void ) const;
00758
00760
00774       NVSG_API virtual void assignDirectedLightToEffectLight( nvsg::CgFxEffect * effect
00775                                                             , nvsg::CgFxParameter lightParam
00776                                                             , const nvsg::DirectedLight * directedLight
00777                                                             , const nvmath::Mat44f& modelToWorld
00778                                                             );
00779
00781
00795       NVSG_API virtual void assignPointLightToEffectLight( nvsg::CgFxEffect * effect
00796                                                          , nvsg::CgFxParameter lightParam
00797                                                          , const nvsg::PointLight * pointLight
00798                                                          , const nvmath::Mat44f& modelToWorld
00799                                                          );
00800
00802
00816       NVSG_API virtual void assignSpotLightToEffectLight( nvsg::CgFxEffect * effect
00817                                                         , nvsg::CgFxParameter lightParam
00818                                                         , const nvsg::SpotLight * spotLight
00819                                                         , const nvmath::Mat44f& modelToWorld
00820                                                         );
00821
00823
00837       NVSG_API virtual void assignCustomLightToEffectLight( nvsg::CgFxEffect * effect
00838                                                           , nvsg::CgFxParameter lightParam
00839                                                           , const nvsg::LightSource * customLight
00840                                                           , const nvmath::Mat44f& modelToWorld
00841                                                           );
00842
00843
00845
00849       NVSG_API virtual unsigned int createOcclusionCullID( void );
00850
00852
00855       NVSG_API virtual void destroyOcclusionCullID( unsigned int id
00856                                                   );
00857
00859
00863       NVSG_API virtual void beginOcclusionCullQuery( unsigned int id
00864                                                    );
00865
00867
00871       NVSG_API virtual void endOcclusionCullQuery( unsigned int id
00872                                                  );
00873
00875
00882       NVSG_API virtual unsigned int getOcclusionCullResult( unsigned int id
00883                                                     );
00884
00886
00888       NVSG_API virtual void hiddenBegin( void );
00889
00891
00893       NVSG_API virtual void hiddenEnd( void );
00894
00896       NVSG_API void clearRenderLists( void );
00897
00899
00904       NVSG_API void getMapPosition( size_t &x, size_t &y );
00905
00906     private:
00907       void renderList( std::list<RenderElement*> &rlist );
00908       void renderHiddenList( std::list<RenderElement*> &hlist );
00909       void renderHighlightList( std::list<HighlightElement*> &hlist );
00910       void renderElement( RenderElement * re );
00911       void renderPrimitiveSets(RenderElement* re);
00912       void renderHighlightObjects(HighlightElement* he);
00913       void renderStateAttributes(std::list<const nvsg::StateAttribute*>& alist, bool enable);
00914       void setClipPlanesElement(ClipPlanesElement *p);
00915       void setLightsElement(LightsElement *p);
00916       void setTransformElement(TransformElement *p);
00917       void traverseHeadLight( const nvsg::LightSource * p );
00918
00919       // gathers all available effect lights in a plain vector
00920       size_t getEffectLights( nvsg::CgFxEffect * effect
00921                             , std::vector<nvsg::CgFxParameter>& lights) const;
00922
00923       // reset lights[first] to lights[last-1]
00924       void resetEffectLights( nvsg::CgFxEffect * effect
00925                             , const std::vector<nvsg::CgFxParameter>& lights
00926                             , size_t first
00927                             , size_t last );
00928
00929       // sets effect light values
00930       void setEffectLights( nvsg::CgFxEffect * effect
00931                           , const std::vector<nvsg::CgFxParameter>& lights
00932                           , LightsElement * headLights
00933                           , LightsElement * currLights );
00934
00935      // returns an object code to lookup the right render function for the given object.
00936      // returns OC_INVALID if no appropriate render function could be found for the object.
00937      unsigned int getObjectRenderCode(const nvsg::Object * obj);
00938
00939      // update visible and hidden list by the occlusion test results
00940      void occlusionTest( std::list<RenderElement*> &visibleList, std::list<RenderElement*> &hiddenList );
00941
00942      void clearRenderList( std::list<RenderElement*> &rlist );
00943      template <typename REType>
00944        void clearRenderList( std::list<REType*>& rlist );
00945      template <typename REType>
00946        void clearRenderVector( std::vector<REType*>& rlist );
00947      void updateTransformElement( TransformElement * te );
00948
00949     private:
00950       bool            m_faceCullingBack;
00951       bool            m_faceCullingFront;
00952       bool            m_faceCullingOverwrite;
00953       nvsg::FaceMode  m_faceMode;
00954       bool            m_faceModeOverwrite;
00955       bool            m_twoSidedLighting;
00956       bool            m_twoSidedLightingOverwrite;
00957       bool            m_lineAntiAliasing;
00958       float           m_lineWidth;
00959       bool            m_pointAntiAliasing;
00960       float           m_pointSize;
00961       SortingPolicy   m_sortingPolicy;
00962
00963       // used with state handling during rendering
00964       std::list<const nvsg::StateAttribute *> m_currentStateAttribs;
00965
00966       std::stack<ClipPlanesElement *>   m_clipPlanesStack;
00967       ClipPlanesElement               * m_currentClipPlanes;
00968       const nvsg::Camera              * m_currentCamera;
00969       const nvsg::CgFx                * m_currentCgFx;
00970       nvsg::CullData                  * m_currentCullTree;
00971       LightsElement                   * m_currentLights;
00972       const nvsg::Scene               * m_currentScene;
00973       const nvsg::Node                * m_currentRootNode;
00974       const nvsg::Group               * m_currentTransform;
00975       nvutil::Incarnation               m_rootIncarnation;
00976       TransformElement                * m_currentTransformElement;
00977       RenderElement                   * m_currentRenderElement;
00978       LightsElement                   * m_headLights;
00979       RenderElement                   * m_lastRenderElement;
00980       HighlightElement                * m_currentHighlightElement;
00981       ClipPlanesElement               * m_lastClipPlanesElement;
00982       LightsElement                   * m_lastLightsElement;
00983       TransformElement                * m_lastTransformElement;
00984       std::stack<nvmath::Vec3f>         m_currentScaling;
00985       const nvsg::StatePass           * m_currentStatePass;
00986       const nvsg::StatePass           * m_nullStatePass;
00987       const nvsg::StateVariant        * m_currentStateVariant;
00988       const nvsg::StateVariant        * m_lastStateVariant;
00989       bool                              m_isCgFxAware;
00990       std::stack<const nvsg::Group*>    m_groupStack;
00991       RenderElementPool               * m_renderElementPool;
00992       std::stack<LightsElement *>       m_renderLightsStack;
00993       std::list<HighlightElement *>     m_highlightList;
00994       std::list<RenderElement *>        m_overlayList;
00995       bool                              m_overlayPass;
00996       std::stack<bool>                  m_currentOverlay;
00997       std::stack<bool>                  m_currentCullingPrevented;
00998       bool                              m_lastCullingPrevented;
00999       std::list<RenderElement *>        m_visibleOpaqueList;
01000       std::list<RenderElement *>        m_hiddenOpaqueList;
01001       std::list<RenderElement *>        m_visibleTransparentList;
01002       std::list<RenderElement *>        m_hiddenTransparentList;
01003       std::stack<TransformElement *>    m_renderTransformStack;
01004       std::vector<TransformElement *>   m_dynamicTransformElements;
01005       bool                              m_occlusionCulling;
01006       GeometryCacheTechnique            m_geometryCacheTechnique;
01007       JitterTechnique                   m_jitterTechnique;
01008       RenderTechnique                   m_renderTechnique;
01009       ShadowTechnique                   m_shadowTechnique;
01010       size_t                            m_shadowMapSize;
01011       float                             m_shadowMapIntensity;
01012       size_t                            m_textureSizeLimit;
01013       TransparencyTechnique             m_transparencyTechnique;
01014       bool                              m_transparencyTechniqueChanged;
01015       bool                              m_transparentObject;
01016       bool                              m_transparentPass;
01017       OITTechnique                      m_oitTechnique;
01018       size_t                            m_oitMaxPasses;
01019       float                             m_oitThreshold;
01020
01021       // indicates if we need to recreate the render list in doApply
01022       bool                              m_renderListsDirty;
01023
01024       // light tracking
01025       size_t                            m_currentNumLights;
01026
01027       //  map handling
01028       size_t                            m_mapAccSize[2];
01029       int                               m_mapAnchor[2];
01030       size_t                            m_mapMaxRows;
01031       int                               m_mapPos[2];
01032       size_t                            m_mapSize[2];
01033
01034   #if !defined(NDEBUG)
01035       bool                              m_isRendering;
01036       bool                              m_isTraversing;
01037   #endif
01038
01039       nvutil::MemFunTbl<RenderTraverser> * m_mrftbl; // member render function table
01040   };
01041
01042   template<typename RendererType>
01043     inline void RenderTraverser::addObjectRenderer( unsigned int objectCode, RendererType renderer )
01044   {
01045     m_mrftbl->addEntry( objectCode, renderer );
01046   }
01047
01048   inline unsigned int RenderTraverser::getObjectRenderCode(const nvsg::Object * obj)
01049   {
01050     NVSG_TRACE();
01051
01052     unsigned int oc = obj->getObjectCode();
01053     NVSG_ASSERT(oc!=nvsg::OC_INVALID);
01054
01055     if ( !m_mrftbl->testEntry(oc) )
01056     {
01057       unsigned int orgOC = oc;
01058       do
01059       { // came across an unknown object
01060         // move up the object's hierarchy to find an appropriate handler
01061         oc = obj->getHigherLevelObjectCode(oc);
01062         if ( nvsg::OC_INVALID==oc )
01063         { // proceed immediately without handling the object
01064           return oc;
01065         }
01066       }
01067       while ( !m_mrftbl->testEntry(oc) );
01068
01069       // found an appropriate renderer if we get here
01070
01071       // don't loop again for this object - register the handler
01072       addObjectRenderer(orgOC, (*m_mrftbl)[oc]);
01073     }
01074     return oc;
01075   }
01076
01077   inline void RenderTraverser::renderObject( const nvsg::Object* obj )
01078   {
01079     NVSG_TRACE();
01080
01081     if ( m_interrupt )
01082     {
01083       // there was an interrupt request.
01084       // immediately quit rendering
01085       m_interrupted = true;
01086       return;
01087     }
01088
01089     // share-lock the object while being rendered
01090     obj->waitToRead();
01091
01092     unsigned int oc = nvsg::OC_INVALID;
01093     if ( nvsg::OC_INVALID != (oc=getObjectRenderCode(obj)) )
01094     {
01095
01096 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01097       void * __esp__0;
01098       void * __esp__1;
01099       __asm mov __esp__0, esp
01100 #endif
01101       (this->*(void (RenderTraverser::*)(const nvsg::Object*))(*m_mrftbl)[oc])(obj);
01102 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01103       __asm mov __esp__1, esp
01104         NVSG_ASSERT(__esp__1==__esp__0);
01105 #endif
01106     }
01107     obj->doneReading();
01108   }
01109
01110   template <typename T>
01111     inline void RenderTraverser::renderObject( const nvsg::Object* obj, T arg )
01112   {
01113     NVSG_TRACE();
01114
01115     if ( m_interrupt )
01116     {
01117       // there was an interrupt request.
01118       // immediately quit rendering
01119       m_interrupted = true;
01120       return;
01121     }
01122
01123     // share-lock the object while being rendered
01124     obj->waitToRead();
01125
01126     unsigned int oc = nvsg::OC_INVALID;
01127     if ( nvsg::OC_INVALID != (oc=getObjectRenderCode(obj)) )
01128     {
01129 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01130       void * __esp__0;
01131       void * __esp__1;
01132       __asm mov __esp__0, esp
01133 #endif
01134       (this->*(void (RenderTraverser::*)(const nvsg::Object*, T))(*m_mrftbl)[oc])(obj, arg);
01135 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
01136       __asm mov __esp__1, esp
01137         NVSG_ASSERT(__esp__1==__esp__0);
01138 #endif
01139     }
01140     obj->doneReading();
01141   }
01142
01143   inline bool RenderTraverser::isCgFxAware( void ) const
01144   {
01145     return( m_isCgFxAware );
01146   }
01147
01148   inline bool RenderTraverser::isOverlayPass( void ) const
01149   {
01150     return( m_overlayPass );
01151   }
01152
01153   inline bool RenderTraverser::isTransparentPass( void ) const
01154   {
01155     return( m_transparentPass );
01156   }
01157
01158   inline void RenderTraverser::setCgFxAwareness( bool aware )
01159   {
01160     m_isCgFxAware = aware;
01161   }
01162
01163   inline RenderTraverser::GeometryCacheTechnique RenderTraverser::getGeometryCacheTechnique( void ) const
01164   {
01165     return( m_geometryCacheTechnique );
01166   }
01167
01168   inline RenderTraverser::JitterTechnique RenderTraverser::getJitterTechnique( void ) const
01169   {
01170     return( m_jitterTechnique );
01171   }
01172
01173   inline bool RenderTraverser::isBackFaceCulling() const
01174   {
01175     return( m_faceCullingBack );
01176   }
01177
01178   inline bool RenderTraverser::isFrontFaceCulling() const
01179   {
01180     return( m_faceCullingFront );
01181   }
01182
01183   inline void RenderTraverser::setFaceCulling( bool front, bool back )
01184   {
01185     m_faceCullingFront = front;
01186     m_faceCullingBack  = back;
01187   }
01188
01189   inline bool RenderTraverser::isFaceCullingOverwrite() const
01190   {
01191     return( m_faceCullingOverwrite );
01192   }
01193
01194   inline void RenderTraverser::setFaceCullingOverwrite( bool overwrite )
01195   {
01196     m_faceCullingOverwrite = overwrite;
01197   }
01198
01199   inline nvsg::FaceMode RenderTraverser::getFaceMode( void ) const
01200   {
01201     return( m_faceMode );
01202   }
01203
01204   inline void RenderTraverser::setFaceMode( nvsg::FaceMode mode )
01205   {
01206     m_faceMode = mode;
01207   }
01208
01209   inline bool RenderTraverser::isFaceModeOverwrite() const
01210   {
01211     return( m_faceModeOverwrite );
01212   }
01213
01214   inline void RenderTraverser::setFaceModeOverwrite( bool overwrite )
01215   {
01216     m_faceModeOverwrite = overwrite;
01217   }
01218
01219   inline bool RenderTraverser::isTwoSidedLigthing() const
01220   {
01221     return( m_twoSidedLighting );
01222   }
01223
01224   inline void RenderTraverser::setTwoSidedLighting( bool enable )
01225   {
01226     m_twoSidedLighting = enable;
01227   }
01228
01229   inline bool RenderTraverser::isTwoSidedLightingOverwrite() const
01230   {
01231     return( m_twoSidedLightingOverwrite );
01232   }
01233
01234   inline void RenderTraverser::setTwoSidedLightingOverwrite( bool overwrite )
01235   {
01236     m_twoSidedLightingOverwrite = overwrite;
01237   }
01238
01239   inline RenderTraverser::RenderTechnique RenderTraverser::getRenderTechnique( void ) const
01240   {
01241     return( m_renderTechnique );
01242   }
01243
01244   inline RenderTraverser::ShadowTechnique RenderTraverser::getShadowTechnique( void ) const
01245   {
01246     return( m_shadowTechnique );
01247   }
01248
01249   inline size_t RenderTraverser::getShadowMapSize( void ) const
01250   {
01251     return( m_shadowMapSize );
01252   }
01253
01254   inline float RenderTraverser::getShadowMapIntensity( void ) const
01255   {
01256     return( m_shadowMapIntensity );
01257   }
01258
01259   inline void RenderTraverser::setShadowMapIntensity( float intensity )
01260   {
01261     NVSG_ASSERT( ( 0.0f <= intensity ) && ( intensity <= 1.0f ) );
01262     m_shadowMapIntensity = intensity;
01263   }
01264
01265   inline size_t RenderTraverser::getTextureSizeLimit( void ) const
01266   {
01267     return( m_textureSizeLimit );
01268   }
01269
01270   inline RenderTraverser::TransparencyTechnique RenderTraverser::getTransparencyTechnique( void ) const
01271   {
01272     return( m_transparencyTechnique );
01273   }
01274
01275   inline RenderTraverser::OITTechnique RenderTraverser::getOITTechnique( void ) const
01276   {
01277     return( m_oitTechnique );
01278   }
01279
01280   inline size_t RenderTraverser::getOITMaxPasses( void ) const
01281   {
01282     return( m_oitMaxPasses );
01283   }
01284
01285   inline float RenderTraverser::getOITThreshold( void ) const
01286   {
01287     return( m_oitThreshold );
01288   }
01289
01290   inline void RenderTraverser::setOITThreshold( float threshold )
01291   {
01292     NVSG_ASSERT( ( 0.0f <= threshold ) && ( threshold <= 1.0f ) );
01293     m_oitThreshold = threshold;
01294   }
01295
01296   inline const nvsg::CgFx * RenderTraverser::getCurrentCgFx( void ) const
01297   {
01298     NVSG_ASSERT( m_isRendering );
01299     return( m_currentCgFx );
01300   }
01301
01302   inline void RenderTraverser::setLineAntiAliasing( bool onOff )
01303   {
01304     m_lineAntiAliasing = onOff;
01305   }
01306
01307   inline bool RenderTraverser::isLineAntiAliasingEnabled() const
01308   {
01309     return( m_lineAntiAliasing );
01310   }
01311
01312   inline float RenderTraverser::getLineWidth( void ) const
01313   {
01314     return( m_lineWidth );
01315   }
01316
01317   inline void RenderTraverser::setLineWidth( float width )
01318   {
01319     m_lineWidth = width;
01320   }
01321
01322   inline void RenderTraverser::setPointAntiAliasing( bool onOff )
01323   {
01324     m_pointAntiAliasing = onOff;
01325   }
01326
01327   inline bool RenderTraverser::isPointAntiAliasingEnabled() const
01328   {
01329     return( m_pointAntiAliasing );
01330   }
01331
01332   inline float RenderTraverser::getPointSize( void ) const
01333   {
01334     return( m_pointSize );
01335   }
01336
01337   inline void RenderTraverser::setPointSize( float size )
01338   {
01339     m_pointSize = size;
01340   }
01341
01342   inline void RenderTraverser::setSortingPolicy( SortingPolicy sp )
01343   {
01344     m_sortingPolicy = sp;
01345   }
01346
01347   inline RenderTraverser::SortingPolicy RenderTraverser::getSortingPolicy( void ) const
01348   {
01349     return( m_sortingPolicy );
01350   }
01351
01352   inline bool RenderTraverser::isOcclusionCulling( void ) const
01353   {
01354     return( m_occlusionCulling );
01355   }
01356
01357   inline void RenderTraverser::getMapPosition( size_t &x, size_t &y )
01358   {
01359     x = m_mapPos[0];
01360     y = m_mapPos[1];
01361   }
01362 }
Generated on Fri Aug 4 08:33:08 2006 for NVSGSDK by NVIDIA


Scene.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Animation.h"
#include "nvsg/Billboard.h"
#include "nvsg/Camera.h"
#include "nvsg/Node.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 | nvmath
namespace | nvsg

Detailed Description

Generated on Fri Aug 4 08:35:25 2006 for NVSGSDK by NVIDIA


Scene.h Source File

Scene.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/Animation.h"
00018 #include "nvsg/Billboard.h"
00019 #include "nvsg/Camera.h"
00020 #include "nvsg/Node.h"
00021
00022 namespace nvmath
00023 {
00024   class Trafo;
00025 }
00026
00027 namespace nvsg
00028 {
00037   class Scene : public nvutil::RCObject
00038               , public nvutil::ISWMRSync
00039   {
00040     public:
00046       NVSG_API static const Scene * create();
00047
00053       NVSG_API const nvmath::Vec3f & getAmbientColor() const;
00054
00060       NVSG_API void setAmbientColor( const nvmath::Vec3f & color );
00061
00067       NVSG_API const nvmath::Vec3f & getBackColor()  const;
00068
00074       NVSG_API void setBackColor( const nvmath::Vec3f & color );
00075
00081       NVSG_API size_t getNumberOfCameras() const;
00082
00089       NVSG_API const Camera * getCamera( size_t index) const;
00090
00095       NVSG_API void addCamera( const Camera * camera );
00096
00103       NVSG_API void removeCamera( size_t index );
00104
00110       NVSG_API size_t getNumberOfCameraAnimations() const;
00111
00120       NVSG_API const Animation<nvmath::Trafo> * getCameraAnimation( size_t index ) const;
00121
00128       NVSG_API void addCameraAnimation( const Animation<nvmath::Trafo> * animation );
00129
00136       NVSG_API void removeCameraAnimation( size_t index );
00137
00142       NVSG_API size_t getNumberOfFrames() const;
00143
00147       NVSG_API const Node * getRootNode() const;
00148
00154       NVSG_API void setRootNode( const Node * root );
00155
00161       NVSG_API bool containsCgFx() const;
00162
00166       NVSG_API bool containsLight() const;
00167
00171       NVSG_API bool containsTransparentGeometry() const;
00172
00173     protected:
00176       NVSG_API Scene();
00177
00182       NVSG_API virtual ~Scene();
00183
00184     private:
00185       nvmath::Vec3f                                   m_ambientColor;
00186       nvmath::Vec3f                                   m_backColor;
00187       std::vector<const Camera *>                     m_cameras;
00188       std::vector<const Animation<nvmath::Trafo>*>    m_cameraAnimations;
00189       const Node                                    * m_root;
00190   };
00191
00192   inline void Scene::addCamera( const Camera *pCamera )
00193   {
00194     NVSG_TRACE();
00195     m_cameras.push_back( pCamera );
00196     pCamera->addRef();
00197   }
00198
00199   inline const Camera * Scene::getCamera( size_t index ) const
00200   {
00201     NVSG_TRACE();
00202     NVSG_ASSERT( index < m_cameras.size() );
00203     return( m_cameras[index] );
00204   }
00205
00206   inline void Scene::removeCamera( size_t index )
00207   {
00208     NVSG_TRACE();
00209     NVSG_ASSERT(index < m_cameras.size());
00210
00211     m_cameras[index]->removeRef();
00212     m_cameras.erase(m_cameras.begin()+index);
00213   }
00214
00215   inline void Scene::addCameraAnimation( const Animation<nvmath::Trafo> *pAnimation )
00216   {
00217     NVSG_TRACE();
00218     m_cameraAnimations.push_back( pAnimation );
00219     pAnimation->addRef();
00220   }
00221
00222   inline const Animation<nvmath::Trafo> * Scene::getCameraAnimation( size_t index ) const
00223   {
00224     NVSG_TRACE();
00225     NVSG_ASSERT( index < m_cameraAnimations.size() );
00226     return( m_cameraAnimations[index] );
00227   }
00228
00229   inline void Scene::removeCameraAnimation( size_t index )
00230   {
00231     NVSG_TRACE();
00232     NVSG_ASSERT(index < m_cameraAnimations.size());
00233
00234     m_cameraAnimations[index]->removeRef();
00235     m_cameraAnimations.erase(m_cameraAnimations.begin()+index);
00236   }
00237
00238   inline size_t Scene::getNumberOfCameras() const
00239   {
00240     NVSG_TRACE();
00241     return( m_cameras.size() );
00242   }
00243
00244   inline size_t Scene::getNumberOfCameraAnimations() const
00245   {
00246     NVSG_TRACE();
00247     return( m_cameraAnimations.size() );
00248   }
00249
00250   inline const Node * Scene::getRootNode() const
00251   {
00252     NVSG_TRACE();
00253     return( m_root );
00254   }
00255
00256   inline size_t Scene::getNumberOfFrames() const
00257   {
00258     NVSG_TRACE();
00259     NVSG_ASSERT( m_root );
00260
00261     // We currently only support animations containing the same number of frames.
00262     // We have to think about handling animations with different numbers of frames.
00263     size_t nof = m_root->getNumberOfFrames();
00264     for ( size_t i=0 ; !nof && i<m_cameraAnimations.size() ; i++ )
00265     {
00266       nof = m_cameraAnimations[i]->getNumberOfFrames();
00267     }
00268
00269 #if !defined(NDEBUG)
00270     for ( size_t i=0 ; i<m_cameraAnimations.size() ; i++ )
00271     {
00272       size_t nofca = m_cameraAnimations[i]->getNumberOfFrames();
00273       NVSG_ASSERT( ( nofca == 0 ) || ( nofca == nof ) );
00274     }
00275 #endif
00276
00277     return( nof );
00278   }
00279
00280   inline bool Scene::containsCgFx() const
00281   {
00282     NVSG_TRACE();
00283     return( m_root->containsCgFx() );
00284   }
00285
00286   inline bool Scene::containsLight() const
00287   {
00288     NVSG_TRACE();
00289     return( m_root->containsLight() );
00290   }
00291
00292   inline bool Scene::containsTransparentGeometry() const
00293   {
00294     NVSG_TRACE();
00295     return( m_root->containsTransparentGeometry() );
00296   }
00297
00298   inline const nvmath::Vec3f& Scene::getAmbientColor() const
00299   {
00300     NVSG_TRACE();
00301     return( m_ambientColor );
00302   }
00303
00304   inline void Scene::setAmbientColor( const nvmath::Vec3f &color )
00305   {
00306     NVSG_TRACE();
00307     m_ambientColor = color;
00308   }
00309
00310   inline const nvmath::Vec3f& Scene::getBackColor() const
00311   {
00312     NVSG_TRACE();
00313     return( m_backColor );
00314   }
00315
00316   inline void Scene::setBackColor( const nvmath::Vec3f &color )
00317   {
00318     NVSG_TRACE();
00319     m_backColor = color;
00320   }
00321 } //  namspace nvsg
Generated on Fri Aug 4 08:33:08 2006 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 Fri Aug 4 08:35:25 2006 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
00017 #include "nvtraverser/Traverser.h"
00018
00019 namespace nvsg
00020 {
00021   class IndependentPrimitiveSet;
00022   class MeshedPrimitiveSet;
00023   class Path;
00024   class StrippedPrimitiveSet;
00025   template<typename T> class Animation;
00026   template<typename T> class InterpolatedAnimation;
00027 }
00028
00029 namespace nvtraverser
00030 {
00032
00034   class SearchTraverser : public Traverser
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<const nvsg::Object*> & getResults( void ) const;
00050
00052
00054       NVSG_API void setClassName( const std::string& name
00055                                 );
00056
00058
00061       NVSG_API void setBaseClassSearch( bool enable
00062                                       );
00063
00064     protected:
00066       NVSG_API virtual ~SearchTraverser(void);
00067
00069       NVSG_API virtual void  doApply( const nvsg::Scene * scene
00070                                     );
00071
00073       NVSG_API virtual void handleBillboard(
00074         const nvsg::Billboard * p
00075         );
00076
00078       NVSG_API virtual void handleGeoNode(
00079         const nvsg::GeoNode * p
00080       );
00081
00083       NVSG_API virtual void handleGroup(
00084         const nvsg::Group * p
00085       );
00086
00088       NVSG_API virtual void handleLOD(
00089         const nvsg::LOD * p
00090       );
00091
00093       NVSG_API virtual void handleSwitch(
00094         const nvsg::Switch * p
00095       );
00096
00098       NVSG_API virtual void handleTransform(
00099         const nvsg::Transform * p
00100       );
00101
00103       NVSG_API virtual void handleAnimatedTransform(
00104         const nvsg::AnimatedTransform * p
00105       );
00106
00108       NVSG_API virtual void handleDirectedLight(
00109         const nvsg::DirectedLight * p
00110       );
00111
00113       NVSG_API virtual void handlePointLight(
00114         const nvsg::PointLight * p
00115       );
00116
00118       NVSG_API virtual void handleSpotLight(
00119         const nvsg::SpotLight * p
00120       );
00121
00123       NVSG_API virtual void handleLines(
00124         const nvsg::Lines * p
00125         );
00126
00128       NVSG_API virtual void handleLineStrips(
00129         const nvsg::LineStrips * p
00130         );
00131
00133       NVSG_API virtual void handlePoints(
00134         const nvsg::Points * p
00135         );
00136
00138       NVSG_API virtual void handleQuadMeshes(
00139         const nvsg::QuadMeshes * p
00140         );
00141
00143       NVSG_API virtual void handleQuads(
00144         const nvsg::Quads * p
00145       );
00146
00148       NVSG_API virtual void handleAnimatedQuads(
00149         const nvsg::AnimatedQuads * p
00150       );
00151
00153       NVSG_API virtual void handleQuadStrips(
00154         const nvsg::QuadStrips * p
00155       );
00156
00158       NVSG_API virtual void handleTriangles(
00159         const nvsg::Triangles * p
00160       );
00161
00163
00164       NVSG_API virtual void handleAnimatedTriangles(
00165         const nvsg::AnimatedTriangles * p
00166       );
00167
00169       NVSG_API virtual void handleSkinnedTriangles(
00170         const nvsg::SkinnedTriangles * p
00171       );
00172
00174       NVSG_API virtual void handleTriFans(
00175         const nvsg::TriFans * p
00176       );
00177
00179       NVSG_API virtual void handleTriStrips(
00180         const nvsg::TriStrips * p
00181       );
00182
00184       NVSG_API virtual void handleStateSet(
00185         const nvsg::StateSet * p
00186       );
00187
00189       NVSG_API virtual void handleStateVariant(
00190         const nvsg::StateVariant * p
00191         );
00192
00194       NVSG_API virtual void handleStatePass(
00195         const nvsg::StatePass * p
00196         );
00197
00199       NVSG_API virtual void handleBlendAttribute(
00200         const nvsg::BlendAttribute * p
00201         );
00202
00204       NVSG_API virtual void handleCgFx(
00205         const nvsg::CgFx * p
00206       );
00207
00209       NVSG_API virtual void handleDepthAttribute(
00210         const nvsg::DepthAttribute * p
00211         );
00212
00214       NVSG_API virtual void handleFaceAttribute(
00215         const nvsg::FaceAttribute * p
00216       );
00217
00219       NVSG_API virtual void handleLineAttribute(
00220         const nvsg::LineAttribute * p
00221         );
00222
00224       NVSG_API virtual void handleMaterial(
00225         const nvsg::Material * p
00226       );
00227
00229       NVSG_API virtual void handlePointAttribute(
00230         const nvsg::PointAttribute * p
00231         );
00232
00234       NVSG_API virtual void handleTextureAttribute(
00235         const nvsg::TextureAttribute * p
00236       );
00237
00239       NVSG_API virtual void handleParallelCamera(
00240         const nvsg::ParallelCamera * p
00241       , const nvsg::Node * root
00242       );
00243
00245
00246       NVSG_API virtual void handlePerspectiveCamera(
00247         const nvsg::PerspectiveCamera * p
00248       , const nvsg::Node * root
00249       );
00250
00252       NVSG_API virtual void handleFramedTrafoAnimation(
00253         const nvsg::FramedAnimation<nvmath::Trafo> * p
00254       );
00255
00257
00258       NVSG_API virtual void handleFramedVNVectorAnimation(
00259         const nvsg::FramedAnimation<nvsg::VNVector> * p
00260       );
00261
00263       NVSG_API virtual void handleLinearInterpolatedTrafoAnimation(
00264         const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * p
00265       );
00266
00268       NVSG_API virtual void handleLinearInterpolatedVNVectorAnimation(
00269         const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> * p
00270       );
00271
00272
00274
00275       NVSG_API virtual void search( const nvsg::Animation<nvmath::Trafo> *p
00276                                     );
00277
00279
00280       NVSG_API virtual void search( const nvsg::Animation<nvsg::VNVector> *p
00281                                   );
00282
00284
00285       NVSG_API virtual void search( const nvsg::Camera *p
00286                                   );
00287
00289
00290       NVSG_API virtual void search( const nvsg::Drawable *p
00291                                   );
00292
00294
00295       NVSG_API virtual void search( const nvsg::Group *p
00296                                   );
00297
00299
00300       NVSG_API virtual void search( const nvsg::IndependentPrimitiveSet * p
00301                                   );
00302
00304
00305       NVSG_API virtual void search( const nvsg::InterpolatedAnimation<nvmath::Trafo> *p
00306                                   );
00307
00309
00310       NVSG_API virtual void search( const nvsg::InterpolatedAnimation<nvsg::VNVector> *p
00311                                   );
00312
00314
00315       NVSG_API virtual void search( const nvsg::LightSource *p
00316                                   );
00317
00319
00320       NVSG_API virtual void search( const nvsg::MeshedPrimitiveSet * p
00321         );
00322
00324
00325       NVSG_API virtual void search( const nvsg::Node *p
00326                                   );
00327
00329
00330       NVSG_API virtual void search( const nvsg::Object *p
00331                                   );
00332
00334
00335       NVSG_API virtual void search( const nvsg::PrimitiveSet *p
00336                                   );
00337
00339
00340       NVSG_API virtual void search( const nvsg::Quads *p
00341                                   );
00342
00344
00345       NVSG_API virtual void search( const nvsg::StateAttribute *p
00346                                   );
00347
00349
00350       NVSG_API virtual void search( const nvsg::StrippedPrimitiveSet * p
00351                                   );
00352
00354
00355       NVSG_API virtual void search( const nvsg::Transform *p
00356                                   );
00357
00359
00360       NVSG_API virtual void search( const nvsg::Triangles *p
00361                                   );
00362
00363     private:
00364       void  addItem( const nvsg::Object* T );
00365
00366       nvsg::Path                        * m_currentPath;
00367       std::string                         m_className;
00368       std::vector<const nvsg::Path*>      m_paths;
00369       std::vector<const nvsg::Object*>    m_results;
00370       bool                                m_searchBaseClass;
00371   };
00372
00373   inline const std::vector<const nvsg::Object*> & SearchTraverser::getResults( void ) const
00374   {
00375     return( m_results );
00376   }
00377
00378   inline const std::vector<const nvsg::Path*> & SearchTraverser::getPaths( void ) const
00379   {
00380     return( m_paths );
00381   }
00382
00383   inline  void  SearchTraverser::setClassName( const std::string& name )
00384   {
00385     m_className = name;
00386   }
00387
00388   inline  void  SearchTraverser::setBaseClassSearch( bool enable )
00389   {
00390     m_searchBaseClass = enable;
00391   }
00392
00393 }
Generated on Fri Aug 4 08:33:08 2006 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 Fri Aug 4 08:35:27 2006 for NVSGSDK by NVIDIA


Shape.h Source File

Shape.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/PrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00026   class Shape : public Drawable
00027   {
00028     public:
00032       NVSG_API size_t getNumberOfPrimitiveSets() const;
00033
00040       NVSG_API const PrimitiveSet * getPrimitiveSet( size_t index ) const;
00041
00045       NVSG_API virtual const Shape * clone() const = 0;
00046
00058       NVSG_API virtual bool isEquivalent( const Object * p
00059                                         , bool ignoreNames
00060                                         , bool deepCompare ) const;
00061
00062     protected:
00066       NVSG_API Shape();
00067
00072       NVSG_API Shape( const Shape& rhs );
00073
00077       NVSG_API virtual ~Shape();
00078
00084       NVSG_API void addPrimitiveSet( const PrimitiveSet * p );
00085
00093       NVSG_API void removePrimitiveSet( size_t index );
00094
00101       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere() const;
00102
00108       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00109
00116       NVSG_API Shape & operator=(const Shape & rhs);
00117
00118     private:
00119       std::vector<const PrimitiveSet *>   m_primitiveSets;
00120   };
00121
00122   inline size_t Shape::getNumberOfPrimitiveSets() const
00123   {
00124     NVSG_TRACE();
00125     return( m_primitiveSets.size() );
00126   }
00127
00128   inline const PrimitiveSet * Shape::getPrimitiveSet( size_t i ) const
00129   {
00130     NVSG_TRACE();
00131     NVSG_ASSERT( i < m_primitiveSets.size() );
00132     return( m_primitiveSets[i] );
00133   }
00134
00135 } //  namespace nvsg
Generated on Fri Aug 4 08:33:08 2006 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 Fri Aug 4 08:35:35 2006 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 Fri Aug 4 08:33:08 2006 for NVSGSDK by NVIDIA


SkinnedTriangles.h File Reference

#include "nvsgcommon.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 Fri Aug 4 08:35:36 2006 for NVSGSDK by NVIDIA


SkinnedTriangles.h Source File

SkinnedTriangles.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 "nvmath/Trafo.h"
00018 #include "nvsg/Animation.h"
00019 #include "nvsg/Triangles.h"
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 const Animation<nvmath::Trafo> * getAnimation() const;
00054
00061       NVSG_API const nvmath::Mat44f & getMatrix( size_t frame ) const;
00062
00065       NVSG_API float getWeight() const;
00066
00072       NVSG_API void setAnimation( const Animation<nvmath::Trafo> * 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()( size_t 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       const Animation<nvmath::Trafo>  * m_animation;
00121       nvmath::Mat44f                    m_baseInverse;
00122       float                             m_weight;
00123
00124       mutable size_t  m_currFrame;
00125       mutable nvmath::Mat44f  m_currTrafo;
00126   };
00127
00128   inline const Animation<nvmath::Trafo> * 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
00176   typedef struct
00177   {
00178     std::vector<Bone> m_bones;
00179     nvmath::Vec3f     m_normal;
00180     nvmath::Vec3f     m_vertex;
00181   } Skin;
00182
00188   class SkinnedTriangles : public Triangles
00189   {
00190     public:
00194       NVSG_API static const SkinnedTriangles * create();
00195
00202       NVSG_API static const SkinnedTriangles * createFromBase( const Triangles &rhs );
00203
00207       NVSG_API virtual const SkinnedTriangles * clone() const;
00208
00212       NVSG_API virtual bool isDataShared() const;
00213
00217       NVSG_API virtual DataID getDataID() const;
00218
00221       NVSG_API virtual size_t getNumberOfFrames() const;
00222
00231       NVSG_API void setAnimationFrame( size_t frame
00232                                      , bool calculateTangentSpace );
00233
00240       NVSG_API size_t getNumberOfSkins() const;
00241
00245       NVSG_API const Skin * getSkins() const;
00246
00255       NVSG_API void setSkins( const Skin * skins
00256                             , size_t numSkins );
00257
00273       NVSG_API void setSkins( size_t pos
00274                             , const Skin * skins
00275                             , size_t numSkins );
00276
00282       NVSG_API SkinnedTriangles & operator=(const SkinnedTriangles & rhs);
00283
00293       NVSG_API virtual bool isEquivalent( const Object * p
00294                                         , bool ignoreNames
00295                                         , bool deepCompare ) const;
00296
00297     protected:
00301       NVSG_API SkinnedTriangles();
00302
00309       NVSG_API SkinnedTriangles( const Triangles &rhs );
00310
00315       NVSG_API SkinnedTriangles( const SkinnedTriangles &rhs );
00316
00321       NVSG_API virtual ~SkinnedTriangles();
00322
00328       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00329
00330     private:
00331       nvutil::RCPtr<nvutil::RCVector<Skin> >  m_skins; // sharable skins
00332   };
00333
00334   // - - - - - - - - - - - - - - - - - - - - - - - - -
00335   // inlines
00336   // - - - - - - - - - - - - - - - - - - - - - - - - -
00337
00338   inline size_t SkinnedTriangles::getNumberOfSkins()  const
00339   {
00340     NVSG_TRACE();
00341     return( m_skins->size() );
00342   }
00343
00344   inline const Skin * SkinnedTriangles::getSkins()  const
00345   {
00346     NVSG_TRACE();
00347     return( &(*m_skins)[0] );
00348   }
00349
00350 } //  namespace nvsg
Generated on Fri Aug 4 08:33:08 2006 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 Fri Aug 4 08:35:37 2006 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
00017 #include "nvtraverser/Traverser.h"
00018
00019 namespace nvsg
00020 {
00021   class IndependentPrimitiveSet;
00022 }
00023
00024 namespace nvtraverser
00025 {
00026   class DestrippingTraverser;
00027
00029
00031   class SmoothTraverser : public Traverser
00032   {
00033     public:
00035       NVSG_API SmoothTraverser(void);
00036
00038       NVSG_API void  setCreaseAngle( float creaseAngle );
00039
00040     protected:
00042       NVSG_API virtual ~SmoothTraverser(void);
00043
00045       NVSG_API virtual void doApply( const nvsg::Scene *scene );
00046
00048
00049       NVSG_API virtual void  handleGeoNode( const nvsg::GeoNode *p
00050                                           );
00051
00053       NVSG_API virtual void  handleQuads( const nvsg::Quads *p
00054                                         );
00055
00057       NVSG_API virtual void  handleTriangles( const nvsg::Triangles *p
00058                                             );
00059
00060 #if !defined(NDEBUG)
00061
00062
00063       NVSG_API virtual void  handleQuadStrips( const nvsg::QuadStrips *p
00064                                              );
00065
00067
00068       NVSG_API virtual void  handleTriFans( const nvsg::TriFans *p
00069                                           );
00070
00072
00073       NVSG_API virtual void  handleTriStrips( const nvsg::TriStrips *p
00074                                             );
00075 #endif
00076
00077     private:
00078       void  handleIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, size_t primitiveSize );
00079
00080     private:
00081       float                                     m_creaseAngle;
00082       DestrippingTraverser                    * m_destrippingTraverser;
00083       std::vector<const nvsg::PrimitiveSet*>    m_primitiveSets;
00084   };
00085 }
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


Sphere3f.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vec3f.h"

Include dependency graph for Sphere3f.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

Defines

#define | NVSG_TRACE_SPHERE3F(s)

Detailed Description

Define Documentation

#define NVSG_TRACE_SPHERE3F ( s )

Value:

NVSG_TRACE_OUT_F(( \
    #s " sphere output:\n" \
    "sphere center: \t%f\t%f\t%f\n" \
    "sphere radius: \t%f%\n" \
    , s.getCenter()[0], s.getCenter()[1], s.getCenter()[2], s.getRadius() ))

Generated on Fri Aug 4 08:35:38 2006 for NVSGSDK by NVIDIA


Sphere3f.h Source File

Sphere3f.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/Vec3f.h"
00017
00018 #if !defined(NDEBUG)
00019 # define NVSG_TRACE_SPHERE3F(s) \
00020   NVSG_TRACE_OUT_F(( \
00021     #s " sphere output:\n" \
00022     "sphere center: \t%f\t%f\t%f\n" \
00023     "sphere radius: \t%f%\n" \
00024     , s.getCenter()[0], s.getCenter()[1], s.getCenter()[2], s.getRadius() ))
00025 #else
00026 # define NVSG_TRACE_SPHERE3F(v)
00027 #endif
00028
00029 namespace nvmath
00030 {
00032
00035   class Sphere3f
00036   {
00037     public:
00039
00041       NVSG_API Sphere3f( void );
00042
00044       NVSG_API Sphere3f( const Vec3f &center
00045                        , float radius
00046                        );
00047
00049
00050       NVSG_API Sphere3f & operator=( const Sphere3f &s
00051                                    );
00052
00054
00057       NVSG_API bool operator==( const Sphere3f& s
00058                               ) const;
00059
00061
00064       NVSG_API bool operator!=( const Sphere3f& s
00065                               ) const;
00066
00068
00071       NVSG_API float operator()( const Vec3f &p
00072                                ) const;
00073
00075
00076       NVSG_API const Vec3f & getCenter( void ) const;
00077
00079       NVSG_API void setCenter( const Vec3f &center
00080                              );
00081
00083
00084       NVSG_API float getRadius( void ) const;
00085
00087       NVSG_API void setRadius( float radius
00088                              );
00089
00090     private:
00091       Vec3f m_center;
00092       float m_radius;
00093   };
00094
00095   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00096   // non-member functions and inlines
00097   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00102   NVSG_API Sphere3f boundingSphere( const Vec3f *points
00103                                   , size_t numberOfPoints
00104                                   );
00105
00110   NVSG_API Sphere3f boundingSphere( const Vec3f *points
00111                                   , const unsigned int * indices
00112                                   , size_t numberOfIndices
00113                                   );
00114
00119   NVSG_API Sphere3f boundingSphere( const Vec3f *points
00120                                   , const std::vector<unsigned int> *strips
00121                                   , size_t numberOfStrips
00122                                   );
00123
00127   NVSG_API Sphere3f boundingSphere( const Sphere3f &s
00128                                   , const Vec3f &p
00129                                   );
00130
00134   NVSG_API Sphere3f boundingSphere( const Sphere3f &s0
00135                                   , const Sphere3f &s1
00136                                   );
00137
00141   NVSG_API Sphere3f intersectingSphere( const Sphere3f &s0
00142                                       , const Sphere3f &s1
00143                                       );
00144
00148   inline void invalidate( Sphere3f & s
00149                         )
00150   {
00151     s.setRadius( -1.0f );
00152   }
00153
00157   inline bool isEmpty( const Sphere3f & s
00158                      )
00159   {
00160     return( s.getRadius() < 0.0f );
00161   }
00162
00163   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00164   // misc
00165   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00166
00169   extern NVSG_API const Sphere3f cUnitSphere;
00170
00171
00172   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00173   // inlines Sphere3f
00174   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00175   inline Sphere3f & Sphere3f::operator=( const Sphere3f &s )
00176   {
00177     m_center = s.m_center;
00178     m_radius = s.m_radius;
00179     return( *this );
00180   }
00181
00182   inline bool Sphere3f::operator==( const Sphere3f &s ) const
00183   {
00184     return( ( m_center == s.m_center ) && ( fabsf( m_radius - s.m_radius ) < FLT_EPSILON ) );
00185   }
00186
00187   inline bool Sphere3f::operator!=( const Sphere3f &s ) const
00188   {
00189     return( ! (this->operator==( s )) );
00190   }
00191
00192   inline float Sphere3f::operator()( const Vec3f &p ) const
00193   {
00194     return( distance( m_center, p ) - m_radius );
00195   }
00196
00197   inline const Vec3f & Sphere3f::getCenter( void ) const
00198   {
00199     return( m_center );
00200   }
00201
00202   inline void Sphere3f::setCenter( const Vec3f &center )
00203   {
00204     m_center = center;
00205   }
00206
00207   inline float Sphere3f::getRadius( void ) const
00208   {
00209     return( m_radius );
00210   }
00211
00212   inline void Sphere3f::setRadius( float radius )
00213   {
00214     m_radius = radius;
00215   }
00216
00217 } // end namespace nvmath
Generated on Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:35:39 2006 for NVSGSDK by NVIDIA


SpotLight.h Source File

SpotLight.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/LightSource.h"
00017
00018 namespace nvsg
00019 {
00040   class SpotLight : public LightSource
00041   {
00042     public:
00047       NVSG_API static const SpotLight * create();
00048
00056       NVSG_API static const SpotLight * createFromBase( const LightSource &rhs );
00057
00061       NVSG_API virtual const SpotLight * clone() const;
00062
00067       NVSG_API const nvmath::Vec3f & getPosition() const;
00068
00073       NVSG_API void setPosition( const nvmath::Vec3f & position );
00074
00079       NVSG_API nvmath::Vec3f getDirection() const;
00080
00086       NVSG_API void setDirection( const nvmath::Vec3f & direction );
00087
00093       NVSG_API const nvmath::Quatf & getOrientation() const;
00094
00100       NVSG_API void setOrientation( const nvmath::Quatf & orientation );
00101
00108       NVSG_API bool isAttenuated() const;
00109
00120       NVSG_API void  getAttenuation( float &c
00121                                    , float &l
00122                                    , float &q ) const;
00123
00133       NVSG_API const nvmath::Vec3f& getAttenuation() const;
00134
00145       NVSG_API void setAttenuation( float c
00146                                   , float l
00147                                   , float q );
00148
00158       NVSG_API void setAttenuation( const nvmath::Vec3f &attenuation );
00159
00165       NVSG_API float getCutoffAngle() const;
00166
00172       NVSG_API void setCutoffAngle( float ca );
00173
00179       NVSG_API float getFalloffExponent() const;
00180
00186       NVSG_API void setFalloffExponent( float fe );
00187
00194       NVSG_API SpotLight & operator=(const SpotLight & rhs);
00195
00206       NVSG_API virtual bool isEquivalent( const Object * p
00207                                         , bool ignoreNames
00208                                         , bool deepCompare ) const;
00209
00210     protected:
00213       NVSG_API SpotLight();
00214
00220       NVSG_API SpotLight( const LightSource &rhs );
00221
00225       NVSG_API SpotLight( const SpotLight &rhs );
00226
00231       NVSG_API virtual ~SpotLight();
00232
00233     private:
00234       nvmath::Vec3f m_attenuation;
00235       float         m_cutoffAngle;
00236       float         m_falloffExponent;
00237   };
00238
00239   inline  const nvmath::Vec3f&  SpotLight::getAttenuation()  const
00240   {
00241     NVSG_TRACE();
00242     return m_attenuation;
00243   }
00244
00245   inline  void  SpotLight::getAttenuation( float &c, float &l, float &q )  const
00246   {
00247     NVSG_TRACE();
00248     c = m_attenuation[0];
00249     l = m_attenuation[1];
00250     q = m_attenuation[2];
00251   }
00252
00253   inline  float SpotLight::getCutoffAngle()  const
00254   {
00255     NVSG_TRACE();
00256     return( m_cutoffAngle );
00257   }
00258
00259   inline  float SpotLight::getFalloffExponent()  const
00260   {
00261     NVSG_TRACE();
00262     return( m_falloffExponent );
00263   }
00264
00265   inline  bool  SpotLight::isAttenuated()  const
00266   {
00267     NVSG_TRACE();
00268     return(   ( m_attenuation[0] != 1.0f )
00269           ||  ( m_attenuation[1] != 0.0f )
00270           ||  ( m_attenuation[2] != 0.0f )
00271           );
00272   }
00273
00274   inline  void  SpotLight::setAttenuation( float c, float l, float q )
00275   {
00276     NVSG_TRACE();
00277     m_attenuation[0] = c;
00278     m_attenuation[1] = l;
00279     m_attenuation[2] = q;
00280     increaseIncarnation();
00281   }
00282
00283   inline void SpotLight::setAttenuation( const nvmath::Vec3f & attenuation )
00284   {
00285     NVSG_TRACE();
00286     m_attenuation = attenuation;
00287     increaseIncarnation();
00288   }
00289
00290   inline  void  SpotLight::setCutoffAngle( float ca )
00291   {
00292     NVSG_TRACE();
00293     m_cutoffAngle = ca;
00294     increaseIncarnation();
00295   }
00296
00297   inline  void  SpotLight::setFalloffExponent( float fe )
00298   {
00299     NVSG_TRACE();
00300     m_falloffExponent = fe;
00301     increaseIncarnation();
00302   }
00303
00304   inline nvmath::Vec3f SpotLight::getDirection() const
00305   {
00306     NVSG_TRACE();
00307     return m_trafo.getOrientation() * nvmath::Vec3f (0.f, 0.f, -1.f);
00308   }
00309
00310   inline  const nvmath::Vec3f & SpotLight::getPosition() const
00311   {
00312     NVSG_TRACE();
00313     return m_trafo.getTranslation();
00314   }
00315
00316   inline  void  SpotLight::setPosition( const nvmath::Vec3f & position )
00317   {
00318     NVSG_TRACE();
00319     m_trafo.setTranslation(position);
00320     increaseIncarnation();
00321   }
00322
00323   inline const nvmath::Quatf & SpotLight::getOrientation() const
00324   {
00325     NVSG_TRACE();
00326     return m_trafo.getOrientation();
00327   }
00328
00329   inline void SpotLight::setOrientation( const nvmath::Quatf & orientation )
00330   {
00331     NVSG_TRACE();
00332     m_trafo.setOrientation(orientation);
00333     increaseIncarnation();
00334   }
00335 } //  namespace nvsg
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


StateAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.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 Fri Aug 4 08:35:40 2006 for NVSGSDK by NVIDIA


StateAttribute.h Source File

StateAttribute.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 {
00020   class StatePass;
00021
00027   class StateAttribute : public Object
00028   {
00029     public:
00033       NVSG_API virtual const StateAttribute * clone( void ) const = 0;
00034
00038       NVSG_API size_t getNumberOfParents( void ) const;
00039
00046       NVSG_API const StatePass * getParent( size_t index ) const;
00047
00057       NVSG_API virtual bool isTransparent( void ) const;
00058
00062       NVSG_API void invalidateTransparencyContainment( void );
00063
00064     protected:
00067       NVSG_API StateAttribute( void );
00068
00073       NVSG_API StateAttribute(const StateAttribute& rhs);
00074
00077       NVSG_API virtual ~StateAttribute( void );
00078
00085       NVSG_API virtual void invalidateIncarnation( void );      // from bottom to top
00086
00092       NVSG_API StateAttribute & operator=(const StateAttribute & rhs);
00093
00094     private:
00095       // A StateAttribute can be the child of more than one parent.
00096       // The child-to-parent connection is used, for example, for
00097       // invalidating the parent's transparent Material containment flag.
00098       friend class StatePass;
00099       NVSG_API void addParent( const StatePass * statePass );
00100       NVSG_API void removeParent( const StatePass * statePass );
00101
00102     private:
00103       std::vector<const StatePass *> m_parents;
00104   };
00105
00106   inline size_t StateAttribute::getNumberOfParents( void ) const
00107   {
00108     NVSG_TRACE();
00109     return( m_parents.size() );
00110   }
00111
00112   inline const StatePass * StateAttribute::getParent( size_t index ) const
00113   {
00114     NVSG_TRACE();
00115     NVSG_ASSERT( index < m_parents.size() );
00116     return( m_parents[index] );
00117   }
00118
00119 } //  namespace nvsg
00120
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


StatePass.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.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 Fri Aug 4 08:35:41 2006 for NVSGSDK by NVIDIA


StatePass.h Source File

StatePass.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 {
00020   class StateAttribute;
00021   class StateVariant;
00022
00028   class StatePass : public Object
00029   {
00030     public:
00035       NVSG_API static const StatePass * create();
00036
00043       NVSG_API static const StatePass * createFromBase( const Object & rhs );
00044
00048       NVSG_API virtual const StatePass * clone() const;
00049
00053       NVSG_API size_t getNumberOfOwners() const;
00054
00061       NVSG_API const StateVariant * getOwner( size_t index ) const;
00062
00066       NVSG_API size_t getNumberOfAttributes() const;
00067
00075       NVSG_API const StateAttribute * getAttribute( size_t index ) const;
00076
00082       NVSG_API const StateAttribute * getAttributeByObjectCode( unsigned int objectCode ) const;
00083
00088       NVSG_API size_t getAttributeIndex( const StateAttribute * attribute ) const;
00089
00097       NVSG_API void addAttribute( const StateAttribute * attribute );
00098
00105       NVSG_API void removeAttribute( size_t index );
00106
00111       NVSG_API void removeAttribute( const StateAttribute * attribute );
00112
00118       NVSG_API void removeAttributeByObjectCode( unsigned int objectCode );
00119
00125       NVSG_API bool isTransparent() const;
00126
00131       NVSG_API void invalidateTransparencyContainment();
00132
00137       NVSG_API bool containsCgFx() const;
00138
00143       NVSG_API void invalidateCgFxContainment();
00144
00152       NVSG_API StatePass & operator=(const StatePass & rhs);
00153
00167       NVSG_API virtual bool isEquivalent( const Object * p
00168                                         , bool ignoreNames
00169                                         , bool deepCompare ) const;
00170
00171     protected:
00174       NVSG_API StatePass();
00175
00181       NVSG_API StatePass( const Object &rhs );
00182
00186       NVSG_API StatePass( const StatePass& rhs );
00187
00192       NVSG_API virtual ~StatePass();
00193
00200       NVSG_API virtual void invalidateIncarnation();      // from bottom to top
00201
00207       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00208
00209     private:
00210       // A StatePass can be owned by more than one StateSet. The owner connection is
00211       // used for example to invalidate the owner's containment cache.
00212       friend class StateVariant;
00213       void addOwner( const StateVariant* stateVariant);
00214       void removeOwner( const StateVariant * stateVariant );
00215
00216       void invalidateCaches( const StateAttribute *attribute, bool insert );
00217
00218     private:
00219       std::vector<const StateVariant*>    m_owners;       // owners of this StatePass are collected here
00220       std::vector<const StateAttribute *> m_attribs;
00221
00222       mutable bool  m_containsCgFx;
00223       mutable bool  m_containsCgFxValid;
00224       mutable bool  m_transparencyContainment;
00225       mutable bool  m_transparencyContainmentValid;
00226   };
00227
00228   inline size_t StatePass::getNumberOfOwners() const
00229   {
00230     NVSG_TRACE();
00231     return( m_owners.size() );
00232   }
00233
00234   inline const StateVariant * StatePass::getOwner( size_t index ) const
00235   {
00236     NVSG_TRACE();
00237     NVSG_ASSERT( index < m_owners.size() );
00238     return m_owners[index];
00239   }
00240
00241   inline size_t StatePass::getNumberOfAttributes() const
00242   {
00243     NVSG_TRACE();
00244     return( m_attribs.size() );
00245   }
00246
00247   inline const StateAttribute * StatePass::getAttribute( size_t index ) const
00248   {
00249     NVSG_TRACE();
00250     NVSG_ASSERT( index < m_attribs.size() );
00251     return( m_attribs[index] );
00252   }
00253
00254   inline size_t StatePass::getAttributeIndex( const StateAttribute * attribute ) const
00255   {
00256     NVSG_TRACE();
00257     std::vector<const StateAttribute*>::const_iterator ai =
00258       std::find( m_attribs.begin(), m_attribs.end(), attribute );
00259     return( ( ai != m_attribs.end() ) ? ai - m_attribs.begin() : -1 );
00260   }
00261
00262   inline void StatePass::removeOwner( const StateVariant * stateVariant )
00263   {
00264     NVSG_TRACE();
00265     // the erase-remove idiom is the best way to get rid of specific elements from a vector
00266     m_owners.erase(std::remove(m_owners.begin(), m_owners.end(), stateVariant), m_owners.end());
00267     //  NOTE: don't remove a ref from the owner here
00268   }
00269
00270 } //  namespace nvsg
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


StateSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.h"
#include "nvsg/StateVariant.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 Fri Aug 4 08:35:42 2006 for NVSGSDK by NVIDIA


StateSet.h Source File

StateSet.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 #include "nvsg/StateVariant.h"
00018
00019 namespace nvsg
00020 {
00021   class GeoNode;
00022
00023   typedef unsigned int VariantKey;
00024
00042   class VariantIterator
00043   {
00044     friend class StateSet;
00045
00046     public:
00050       bool operator!=( VariantIterator it ) const;
00051
00055       bool operator==( VariantIterator it ) const;
00056
00057     private:
00058       typedef std::map<VariantKey, const StateVariant *> container_type;
00059       typedef container_type::const_iterator             wrapped_type;
00060       typedef wrapped_type::pointer                      pointer;
00061       typedef wrapped_type::reference                    reference;
00062
00063       VariantIterator();
00064       explicit VariantIterator(wrapped_type it);
00065       pointer operator->() const { return m_iter.operator->(); }
00066       reference operator*() const { return m_iter.operator*(); }
00067       VariantIterator& operator++() { ++m_iter; return *this; } // preincrement
00068       VariantIterator operator++(int) { return VariantIterator(m_iter++); } // postincrement
00069       operator wrapped_type() const { return m_iter; } // implicit conversion to wrapped_type
00070     private:
00071       wrapped_type m_iter;
00072   };
00073
00074   inline VariantIterator::VariantIterator()
00075   : m_iter()
00076   {
00077   }
00078
00079   inline VariantIterator::VariantIterator( wrapped_type it )
00080   : m_iter(it)
00081   {
00082   }
00083
00084   inline bool VariantIterator::operator!=( VariantIterator it ) const
00085   {
00086     return m_iter!=it.m_iter;
00087   }
00088
00089   inline bool VariantIterator::operator==( VariantIterator it ) const
00090   {
00091     return m_iter==it.m_iter;
00092   }
00093
00100   class StateSet : public Object
00101   {
00102     public:
00107       NVSG_API static const StateSet * create();
00108
00115       NVSG_API static const StateSet * createFromBase( const Object &rhs );
00116
00120       NVSG_API virtual const StateSet * clone() const;
00121
00125       NVSG_API size_t getNumberOfOwners() const;
00126
00133       NVSG_API const GeoNode * getOwner( size_t index ) const;
00134
00138       NVSG_API size_t 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 const StateVariant * getActiveVariant() const;
00162
00168       NVSG_API const StateVariant * getVariant( VariantKey key ) const;
00169
00175       NVSG_API const StateVariant * getVariant( VariantIterator it ) const;
00176
00182       NVSG_API VariantKey getVariantKey( VariantIterator it ) const;
00183
00189       NVSG_API VariantKey getActiveVariantKey() const;
00190
00196       NVSG_API void setActiveVariantKey( VariantKey key );
00197
00206       NVSG_API void addVariant( const StateVariant * variant
00207                               , VariantKey key );
00208
00214       NVSG_API void removeVariant( VariantKey key );
00215
00223       NVSG_API void replaceVariant( VariantKey key
00224                                   , const StateVariant * variant );
00225
00232       NVSG_API void replaceVariantKey( VariantKey oldKey
00233                                      , VariantKey newKey );
00234
00241       NVSG_API size_t getNumberOfPasses( VariantKey key = 0 ) const;
00242
00254       NVSG_API const StatePass * getPass( size_t passIndex
00255                                         , VariantKey key = 0 ) const;
00256
00264       NVSG_API void addPass( const StatePass * pass
00265                            , VariantKey key = 0 );
00266
00277       NVSG_API void removePass( size_t passIndex
00278                               , VariantKey key = 0 );
00279
00292       NVSG_API void replacePass( const StatePass * pass
00293                                , size_t passIndex
00294                                , VariantKey key = 0 );
00295
00305       NVSG_API size_t getNumberOfAttributes( size_t passIndex = 0
00306                                            , VariantKey key = 0 ) const;
00307
00321       NVSG_API const StateAttribute * getAttribute( size_t attributeIndex
00322                                                   , size_t passIndex = 0
00323                                                   , VariantKey key = 0 ) const;
00324
00339       NVSG_API const StateAttribute * getAttributeByObjectCode( unsigned int objectCode
00340                                                               , size_t passIndex = 0
00341                                                               , VariantKey key = 0 ) const;
00342
00356       NVSG_API size_t getAttributeIndex( const StateAttribute * attribute
00357                                        , size_t passIndex = 0
00358                                        , VariantKey key = 0 ) const;
00359
00374       NVSG_API void addAttribute( const StateAttribute * attribute
00375                                 , size_t passIndex = 0
00376                                 , VariantKey key = 0 );
00377
00391       NVSG_API void removeAttribute( size_t attributeIndex
00392                                    , size_t passIndex = 0
00393                                    , VariantKey key = 0 );
00394
00406       NVSG_API void removeAttribute( const StateAttribute * attribute
00407                                    , size_t passIndex = 0
00408                                    , VariantKey key = 0 );
00409
00422       NVSG_API void removeAttributeByObjectCode( unsigned int objectCode
00423                                                , size_t passIndex = 0
00424                                                , VariantKey key = 0 );
00425
00431       NVSG_API bool isTransparent() const;
00432
00437       NVSG_API void invalidateTransparencyContainment();
00438
00443       NVSG_API bool containsCgFx() const;
00444
00449       NVSG_API void invalidateCgFxContainment();
00450
00458       NVSG_API StateSet & operator=(const StateSet & rhs);
00459
00473       NVSG_API virtual bool isEquivalent( const Object * p
00474                                         , bool ignoreNames
00475                                         , bool deepCompare ) const;
00476
00477     protected:
00480       NVSG_API StateSet();
00481
00487       NVSG_API StateSet( const Object &rhs );
00488
00492       NVSG_API StateSet( const StateSet& rhs );
00493
00498       NVSG_API virtual ~StateSet();
00499
00506       NVSG_API virtual void invalidateIncarnation();      // from bottom to top
00507
00513       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00514
00515     private:
00516       // A Node can be owned by more than one GeoNode. The owner connection is
00517       // used for example to invalidate the owner's containment cache.
00518       friend class GeoNode;
00519       void addOwner( const GeoNode * geoNode );
00520       void removeOwner( const GeoNode * geoNode );
00521
00522     private:
00523       std::vector<const GeoNode*>               m_owners;       // owners of this state set are collected here
00524       VariantKey                                m_variantKey;
00525       std::map<VariantKey,const StateVariant *> m_variants;
00526
00527       mutable bool  m_containsCgFx;
00528       mutable bool  m_containsCgFxValid;
00529       mutable bool  m_transparencyContainment;
00530       mutable bool  m_transparencyContainmentValid;
00531   };
00532
00533 #if defined( _DEBUG )
00534   inline bool find( std::map<VariantKey,const StateVariant*>::const_iterator it
00535                   , const std::map<VariantKey,const StateVariant*> &m )
00536   {
00537     for ( std::map<VariantKey,const StateVariant*>::const_iterator i = m.begin() ; i!=m.end() ; ++i )
00538     {
00539       if ( i == it )
00540       {
00541         return( true );
00542       }
00543     }
00544     return( false );
00545   }
00546 #endif
00547
00548   inline size_t StateSet::getNumberOfOwners() const
00549   {
00550     NVSG_TRACE();
00551     return( m_owners.size() );
00552   }
00553
00554   inline const GeoNode * StateSet::getOwner( size_t index ) const
00555   {
00556     NVSG_TRACE();
00557     NVSG_ASSERT( index < m_owners.size() );
00558     return m_owners[index];
00559   }
00560
00561   inline void StateSet::removeOwner( const GeoNode * geoNode )
00562   {
00563     NVSG_TRACE();
00564     // the erase-remove idiom is the best way to get rid of specific elements from a vector
00565     m_owners.erase(std::remove(m_owners.begin(), m_owners.end(), geoNode), m_owners.end());
00566     //  NOTE: don't remove a ref from the owner here
00567   }
00568
00569   inline VariantKey StateSet::getActiveVariantKey() const
00570   {
00571     NVSG_TRACE();
00572     return( m_variantKey );
00573   }
00574
00575   inline const StateVariant * StateSet::getActiveVariant() const
00576   {
00577     NVSG_TRACE();
00578     return( getVariant( m_variantKey ) );
00579   }
00580
00581   inline size_t StateSet::getNumberOfVariants() const
00582   {
00583     NVSG_TRACE();
00584     return( m_variants.size() );
00585   }
00586
00587   inline const StateVariant * StateSet::getVariant( VariantKey key ) const
00588   {
00589     NVSG_TRACE();
00590     std::map<VariantKey,const StateVariant*>::const_iterator vi=m_variants.find( key );
00591     return( ( vi != m_variants.end() ) ? vi->second : NULL );
00592   }
00593
00594   inline VariantIterator StateSet::getFirstVariantIterator() const
00595   {
00596     NVSG_TRACE();
00597     return( VariantIterator(m_variants.begin()) );
00598   }
00599
00600   inline VariantIterator StateSet::getNextVariantIterator( VariantIterator it ) const
00601   {
00602     NVSG_TRACE();
00603     return( VariantIterator(++it) );
00604   }
00605
00606   inline VariantIterator StateSet::getLastVariantIterator() const
00607   {
00608     NVSG_TRACE();
00609     return( VariantIterator(m_variants.end()) );
00610   }
00611
00612   inline const StateVariant * StateSet::getVariant( VariantIterator it ) const
00613   {
00614     NVSG_TRACE();
00615 #if defined( _DEBUG )
00616     NVSG_ASSERT( find( it, m_variants ) );
00617 #endif
00618     return( it->second );
00619   }
00620
00621   inline VariantKey StateSet::getVariantKey( VariantIterator it ) const
00622   {
00623     NVSG_TRACE();
00624 #if defined( _DEBUG )
00625     NVSG_ASSERT( find( it, m_variants ) );
00626 #endif
00627     return( it->first );
00628   }
00629
00630   inline size_t StateSet::getNumberOfPasses( VariantKey key ) const
00631   {
00632     NVSG_TRACE();
00633     std::map<VariantKey,const StateVariant*>::const_iterator vi=m_variants.find( key );
00634     return( ( vi != m_variants.end() ) ? vi->second->getNumberOfPasses() : 0 );
00635   }
00636
00637   inline const StatePass * StateSet::getPass( size_t passIndex, VariantKey key ) const
00638   {
00639     NVSG_TRACE();
00640     std::map<VariantKey,const StateVariant*>::const_iterator vi=m_variants.find( key );
00641     NVSG_ASSERT( vi != m_variants.end() );
00642     return( vi->second->getPass( passIndex ) );
00643   }
00644
00645   inline size_t StateSet::getNumberOfAttributes( size_t passIndex, VariantKey key ) const
00646   {
00647     NVSG_TRACE();
00648     std::map<VariantKey,const StateVariant*>::const_iterator vi = m_variants.find( key );
00649     return( ( vi != m_variants.end() ) ? vi->second->getNumberOfAttributes( passIndex ) : 0 );
00650   }
00651
00652   inline const StateAttribute * StateSet::getAttribute( size_t attributeIndex, size_t passIndex, VariantKey key ) const
00653   {
00654     NVSG_TRACE();
00655     std::map<VariantKey,const StateVariant*>::const_iterator vi=m_variants.find( key );
00656     NVSG_ASSERT( vi != m_variants.end() );
00657     return( vi->second->getAttribute( attributeIndex, passIndex ) );
00658   }
00659
00660   inline const StateAttribute * StateSet::getAttributeByObjectCode( unsigned int objectCode, size_t passIndex, VariantKey key ) const
00661   {
00662     NVSG_TRACE();
00663     std::map<VariantKey,const StateVariant*>::const_iterator vi=m_variants.find( key );
00664     NVSG_ASSERT( vi != m_variants.end() );
00665     return( vi->second->getAttributeByObjectCode( objectCode, passIndex ) );
00666   }
00667
00668   inline size_t StateSet::getAttributeIndex( const StateAttribute * attribute, size_t passIndex, VariantKey key ) const
00669   {
00670     NVSG_TRACE();
00671     std::map<VariantKey,const StateVariant*>::const_iterator vi=m_variants.find( key );
00672     NVSG_ASSERT( vi != m_variants.end() );
00673     return( vi->second->getAttributeIndex( attribute, passIndex ) );
00674   }
00675
00676 } //  namespace nvsg
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


StateSetUnifyTraverser.h File Reference

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

Include dependency graph for StateSetUnifyTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Fri Aug 4 08:35:43 2006 for NVSGSDK by NVIDIA


StateSetUnifyTraverser.h Source File

StateSetUnifyTraverser.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
00017 #include "nvsgcommon.h"
00018
00019 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvsg
00022 {
00023   class StateAttribute;
00024   class TextureAttributeItem;
00025 }
00026
00027 namespace nvtraverser
00028 {
00030
00033   class StateSetUnifyTraverser : public OptimizeTraverser
00034   {
00035     public:
00037       NVSG_API StateSetUnifyTraverser( void );
00038
00039     protected:
00041       NVSG_API virtual ~StateSetUnifyTraverser( void );
00042
00048       NVSG_API virtual void doApply( const nvsg::Scene *scene );
00049
00051
00053       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode *p
00054                                          );
00055
00057
00059       NVSG_API virtual void handleStatePass( const nvsg::StatePass * p
00060                                            );
00061
00063
00065       NVSG_API virtual void handleStateSet( const nvsg::StateSet * p
00066         );
00067
00069
00071       NVSG_API virtual void handleStateVariant( const nvsg::StateVariant * p
00072                                               );
00073
00075
00078       NVSG_API virtual void handleTextureAttribute( const nvsg::TextureAttribute *p
00079                                                   );
00080
00081     private:
00082       std::map<unsigned int, std::set<const nvsg::StateAttribute *> > m_stateAttributes;
00083       std::set<const nvsg::StatePass*>                                m_statePasses;
00084       std::set<const nvsg::StateSet*>                                 m_stateSets;
00085       std::set<const nvsg::StateVariant*>                             m_stateVariants;
00086       std::set<const nvsg::TextureAttributeItem*>                     m_textureAttributeItems;
00087   };
00088
00089 }
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


StateVariant.h File Reference

#include "nvsgcommon.h"
#include "nvsg/Object.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 Fri Aug 4 08:35:45 2006 for NVSGSDK by NVIDIA


StateVariant.h Source File

StateVariant.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 #include "nvsg/StatePass.h"
00018
00019 namespace nvsg
00020 {
00021   class StateSet;
00022
00029   class StateVariant : public Object
00030   {
00031     public:
00036       NVSG_API static const StateVariant * create();
00037
00044       NVSG_API static const StateVariant * createFromBase( const Object & rhs );
00045
00049       NVSG_API virtual const StateVariant * clone() const;
00050
00054       NVSG_API size_t getNumberOfOwners() const;
00055
00062       NVSG_API const StateSet * getOwner( size_t index ) const;
00063
00067       NVSG_API size_t getNumberOfPasses() const;
00068
00075       NVSG_API const StatePass * getPass( size_t index ) const;
00076
00081       NVSG_API void addPass( const StatePass * pass );
00082
00089       NVSG_API void removePass( size_t passIndex );
00090
00099       NVSG_API void replacePass( const StatePass * pass
00100                                , size_t index );
00101
00108       NVSG_API size_t getNumberOfAttributes( size_t passIndex = 0 ) const;
00109
00121       NVSG_API const StateAttribute * getAttribute( size_t attributeIndex
00122                                                   , size_t passIndex = 0 ) const;
00123
00134       NVSG_API const StateAttribute * getAttributeByObjectCode( unsigned int objectCode
00135                                                               , size_t passIndex = 0 ) const;
00136
00146       NVSG_API size_t getAttributeIndex( const StateAttribute * attribute
00147                                        , size_t passIndex = 0 ) const;
00148
00160       NVSG_API void addAttribute( const StateAttribute * attribute
00161                                 , size_t passIndex = 0 );
00162
00173       NVSG_API void removeAttribute( size_t attributeIndex
00174                                    , size_t passIndex = 0 );
00175
00183       NVSG_API void removeAttribute( const StateAttribute * attribute
00184                                    , size_t passIndex = 0 );
00185
00194       NVSG_API void removeAttributeByObjectCode( unsigned int objectCode
00195                                                , size_t passIndex );
00196
00202       NVSG_API bool isTransparent() const;
00203
00207       NVSG_API bool isEachPassTransparent() const;
00208
00213       NVSG_API void invalidateTransparencyContainment();
00214
00219       NVSG_API bool containsCgFx() const;
00220
00225       NVSG_API void invalidateCgFxContainment();
00226
00234       NVSG_API StateVariant & operator=( const StateVariant & rhs );
00235
00248       NVSG_API virtual bool isEquivalent( const Object * p
00249                                         , bool ignoreNames
00250                                         , bool deepCompare ) const;
00251
00252     protected:
00255       NVSG_API StateVariant();
00256
00262       NVSG_API StateVariant( const Object &rhs );
00263
00267       NVSG_API StateVariant( const StateVariant& rhs );
00268
00273       NVSG_API virtual ~StateVariant();
00274
00281       NVSG_API virtual void invalidateIncarnation();      // from bottom to top
00282
00288       NVSG_API virtual void validateIncarnation() const;  // from top to bottom
00289
00290     private:
00291       // A StateVariant can be owned by more than one StateSet. The owner connection is
00292       // used for example to invalidate the owner's containment cache.
00293       friend class StateSet;
00294       void addOwner( const StateSet * stateSet );
00295       void removeOwner( const StateSet * stateSet );
00296
00297     private:
00298       std::vector<const StateSet*>    m_owners;       // owners of this StateVariant are collected here
00299       std::vector<const StatePass *>  m_passes;
00300
00301       mutable bool  m_containsCgFx;
00302       mutable bool  m_containsCgFxValid;
00303       mutable bool  m_transparencyContainment;
00304       mutable bool  m_transparencyContainmentValid;
00305   };
00306
00307   inline size_t StateVariant::getNumberOfOwners() const
00308   {
00309     NVSG_TRACE();
00310     return( m_owners.size() );
00311   }
00312
00313   inline const StateSet * StateVariant::getOwner( size_t index ) const
00314   {
00315     NVSG_TRACE();
00316     NVSG_ASSERT( index < m_owners.size() );
00317     return m_owners[index];
00318   }
00319
00320   inline void StateVariant::removeOwner( const StateSet * stateSet )
00321   {
00322     NVSG_TRACE();
00323     // the erase-remove idiom is the best way to get rid of specific elements from a vector
00324     m_owners.erase(std::remove(m_owners.begin(), m_owners.end(), stateSet), m_owners.end());
00325     //  NOTE: don't remove a ref from the owner here
00326   }
00327
00328   inline size_t StateVariant::getNumberOfPasses() const
00329   {
00330     NVSG_TRACE();
00331     return( m_passes.size() );
00332   }
00333
00334   inline const StatePass * StateVariant::getPass( size_t passIndex ) const
00335   {
00336     NVSG_TRACE();
00337     NVSG_ASSERT( passIndex < m_passes.size() );
00338     return( m_passes[passIndex] );
00339   }
00340
00341   inline size_t StateVariant::getNumberOfAttributes( size_t passIndex ) const
00342   {
00343     NVSG_TRACE();
00344     return( ( passIndex < m_passes.size() ) ? m_passes[passIndex]->getNumberOfAttributes() : 0 );
00345   }
00346
00347   inline const StateAttribute * StateVariant::getAttribute( size_t attributeIndex, size_t passIndex ) const
00348   {
00349     NVSG_TRACE();
00350     NVSG_ASSERT( passIndex < m_passes.size() );
00351     return( m_passes[passIndex]->getAttribute( attributeIndex ) );
00352   }
00353
00354   inline const StateAttribute * StateVariant::getAttributeByObjectCode( unsigned int objectCode, size_t passIndex ) const
00355   {
00356     NVSG_TRACE();
00357     NVSG_ASSERT( passIndex < m_passes.size() );
00358     return( m_passes[passIndex]->getAttributeByObjectCode( objectCode ) );
00359   }
00360
00361   inline size_t StateVariant::getAttributeIndex( const StateAttribute * attribute, size_t passIndex ) const
00362   {
00363     NVSG_TRACE();
00364     NVSG_ASSERT( passIndex < m_passes.size() );
00365     return( m_passes[passIndex]->getAttributeIndex( attribute ) );
00366   }
00367
00368   inline void StateVariant::removeAttribute( size_t attributeIndex, size_t passIndex )
00369   {
00370     NVSG_TRACE();
00371     NVSG_ASSERT( passIndex < m_passes.size() );
00372     StatePass * sp = beginEdit( m_passes[passIndex] );
00373     sp->removeAttribute( attributeIndex );
00374     endEdit( sp );
00375   }
00376
00377   inline void StateVariant::removeAttribute( const StateAttribute * attribute, size_t passIndex )
00378   {
00379     NVSG_TRACE();
00380     NVSG_ASSERT( passIndex < m_passes.size() );
00381     StatePass * sp = beginEdit( m_passes[passIndex] );
00382     sp->removeAttribute( attribute );
00383     endEdit( sp );
00384   }
00385
00386   inline void StateVariant::removeAttributeByObjectCode( unsigned int objectCode, size_t passIndex )
00387   {
00388     NVSG_TRACE();
00389     NVSG_ASSERT( passIndex < m_passes.size() );
00390     StatePass * sp = beginEdit( m_passes[passIndex] );
00391     sp->removeAttributeByObjectCode( objectCode );
00392     endEdit( sp );
00393   }
00394
00395 } //  namespace nvsg
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


StrippedPrimitiveSet.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/PrimitiveSet.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 Fri Aug 4 08:35:46 2006 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/nvsg.h"
00017 #include "nvsg/PrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00027   class StrippedPrimitiveSet : public PrimitiveSet
00028   {
00029     public:
00039       NVSG_API virtual bool isDataShared( void ) const;
00040
00048       NVSG_API virtual DataID getDataID( void ) const;
00049
00053       NVSG_API bool hasStrips( void )  const;
00054
00058       NVSG_API size_t getNumberOfStrips( void ) const;
00059
00063       NVSG_API const IndexSet * getStrips() const;
00064
00072       NVSG_API void setStrips( const IndexSet * strips
00073                              , size_t numStrips
00074                              );
00075
00092       NVSG_API void setStrips( size_t pos
00093                              , const IndexSet * strips
00094                              , size_t numStrips
00095                              );
00096
00100       NVSG_API virtual const StrippedPrimitiveSet * clone( void ) const = 0;
00101
00112       NVSG_API virtual bool isEquivalent( const Object * p
00113                                         , bool ignoreNames
00114                                         , bool deepCompare
00115                                         ) const;
00116
00117     protected:
00122       NVSG_API StrippedPrimitiveSet( void );
00123
00129       NVSG_API StrippedPrimitiveSet( const StrippedPrimitiveSet& rhs );
00130
00135       NVSG_API virtual ~StrippedPrimitiveSet( void );
00136
00141       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere( void ) const;
00142
00148       NVSG_API StrippedPrimitiveSet & operator=(const StrippedPrimitiveSet & rhs);
00149
00150     private:
00151       nvutil::RCPtr<nvutil::RCVector<IndexSet> > m_strips;
00152   };
00153
00154
00155   // - - - - - - - - - - - - - - - - - - - - - - - - -
00156   // inlines
00157   // - - - - - - - - - - - - - - - - - - - - - - - - -
00158
00159   inline bool StrippedPrimitiveSet::hasStrips()  const
00160   {
00161     return( !m_strips->empty() );
00162   }
00163
00164   inline size_t StrippedPrimitiveSet::getNumberOfStrips()  const
00165   {
00166     return( m_strips->size() );
00167   }
00168
00169   inline const IndexSet * StrippedPrimitiveSet::getStrips( void ) const
00170   {
00171     NVSG_TRACE();
00172     return( &(*m_strips)[0] );
00173   }
00174 }
Generated on Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:35:47 2006 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
00018 #include "nvsgcommon.h"
00019
00020 #include "nvsg/nvsg.h"
00021 #include "nvsg/Face.h"
00022 #include "nvsg/IndependentPrimitiveSet.h"
00023 #include "nvtraverser/Traverser.h"
00024
00025 namespace nvtraverser
00026 {
00027
00029
00031   class StrippingTraverser : public Traverser
00032   {
00033     public:
00035       NVSG_API StrippingTraverser(void);
00036
00038
00039       void  getMinimalLengths( size_t &triStripLength, size_t &quadStripLength ) const;
00040
00042
00043       void  setMinimalLengths( size_t triStripLength, size_t quadStripLength );
00044
00045     protected:
00047       NVSG_API virtual ~StrippingTraverser(void);
00048
00050       NVSG_API virtual void  handleGeoNode( const nvsg::GeoNode *p
00051                                           );
00052
00054       NVSG_API virtual void handleQuads( const nvsg::Quads *p
00055                                        );
00056
00058       NVSG_API virtual void handleTriangles( const nvsg::Triangles *p
00059                                            );
00060
00061     private:
00062       void    addQuadStrip( const std::list<unsigned int> &vertexList, std::vector<nvsg::IndexSet> &strips
00063                           , nvsg::IndexSet &quads );
00064       void    addTriStrip( const std::list<unsigned int> &vertexList, std::vector<nvsg::IndexSet> &strips
00065                           , nvsg::IndexSet &triangles );
00066       void    connectFaces( const unsigned int *indices, size_t fi, size_t ps, size_t i0, size_t i1
00067                           , const std::vector<std::list<size_t> > &verticesToFaceLists, std::vector<size_t> &faceConnections );
00068       void    copyVertexAttributeData( const nvsg::VertexAttributeSet *from, nvsg::VertexAttributeSet *to
00069                                      , std::vector<nvsg::IndexSet> &strips );
00070       void    copyVertexAttributeData( const nvsg::VertexAttributeSet *from, nvsg::VertexAttributeSet *to
00071                                      , nvsg::IndexSet &indices );
00072       void    cutConnections( const std::list<size_t> &list, size_t vpf, std::vector<std::set<size_t> > &faceSets
00073                             , std::vector<size_t> &faceConnections, std::vector<size_t> &faceConnectionCounts );
00074       void    determineList( const nvsg::Face3 *faces, size_t fi, size_t le, std::list<size_t> &faceList
00075                            , const std::vector<size_t> &faceConnections, std::list<unsigned int> &vertexList );
00076       void    determineList( const nvsg::Face4 *faces, size_t fi, size_t le, std::list<size_t> &faceList
00077                            , const std::vector<size_t> &faceConnections, std::list<unsigned int> &vertexList );
00078       size_t  getNextFaceIndex( const unsigned int *indices, size_t primitiveSize, std::vector<std::set<size_t> > &faceSets
00079                               , nvsg::IndexSet &faces );
00080       void    prepareStripping( const nvsg::IndependentPrimitiveSet *p, size_t primitiveSize
00081                               , std::vector<size_t> &faceConnections, std::vector<size_t> &faceConnectionCounts
00082                               , std::vector<std::set<size_t> > &faceSets );
00083
00084       std::pair<const nvsg::Quads *, const nvsg::QuadStrips *>    createQuadStripsFromQuads( const nvsg::Quads *p );
00085       std::pair<const nvsg::Triangles *, const nvsg::TriStrips *> createTriStripsFromTriangles( const nvsg::Triangles *p );
00086
00087     private:
00088       size_t  m_minimalQuadStrip;
00089       size_t  m_minimalTriStrip;
00090
00091       std::vector<const nvsg::Quads *>     m_quads;
00092       std::vector<const nvsg::Triangles *> m_triangles;
00093       std::map<const nvsg::Quads *, std::pair<const nvsg::Quads *, const nvsg::QuadStrips *> >        m_quadsToQuadStrips;
00094       std::map<const nvsg::Triangles *, std::pair<const nvsg::Triangles *, const nvsg::TriStrips *> > m_trianglesToTriStrips;
00095   };
00096
00097   inline  void StrippingTraverser::getMinimalLengths( size_t &triStripLength, size_t &quadStripLength ) const
00098   {
00099     triStripLength  = m_minimalTriStrip;
00100     quadStripLength = m_minimalQuadStrip;
00101   }
00102
00103   inline  void  StrippingTraverser::setMinimalLengths( size_t triStripLength, size_t quadStripLength )
00104   {
00105     m_minimalTriStrip   = triStripLength;
00106     m_minimalQuadStrip  = quadStripLength;
00107   }
00108 }
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


Switch.h File Reference

#include "nvsgcommon.h"
#include <set>
#include "nvsg/Group.h"

Include dependency graph for Switch.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvsg

Detailed Description

Generated on Fri Aug 4 08:35:48 2006 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"
00016
00017 #include <set>
00018 #include "nvsg/Group.h"
00019
00020 namespace nvsg
00021 {
00043   class Switch : public Group
00044   {
00045     public:
00049       NVSG_API static const Switch * create();
00050
00057       NVSG_API static const Switch * createFromBase(const Group &rhs);
00058
00062       NVSG_API virtual const Switch * clone() const;
00063
00067       NVSG_API void setActive();
00068
00075       NVSG_API void setActive(size_t index);
00076
00080       NVSG_API void setInactive();
00081
00088       NVSG_API void setInactive(size_t index);
00089
00095       NVSG_API size_t getNumberOfActive() const;
00096
00104       NVSG_API size_t getActive(std::vector<size_t>& indices) const;
00105
00111       NVSG_API bool isActive() const;
00112
00118       NVSG_API bool isActive(size_t index) const;
00119
00125       NVSG_API Switch & operator=(const Switch & rhs);
00126
00135       NVSG_API virtual bool isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const;
00136
00137     protected:
00141       NVSG_API Switch();
00142
00149       NVSG_API explicit Switch(const Group &rhs);
00150
00155       NVSG_API Switch(const Switch &rhs);
00156
00161       NVSG_API virtual ~Switch();
00162
00169       NVSG_API virtual void postRemoveChild(size_t index);
00170
00177       NVSG_API virtual void postAddChild(size_t index);
00178
00186       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere( void ) const;
00187
00195       NVSG_API virtual unsigned short determineHintsContainment( unsigned short hints ) const;
00196
00207       NVSG_API virtual bool determineTransparencyContainment( void ) const;
00208
00209     private:
00211       std::set<size_t> m_activeChildren;
00212   };
00213
00214 } //  namespace nvsg
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


SwitchToGroupTraverser.h File Reference

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

Include dependency graph for SwitchToGroupTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Fri Aug 4 08:35:49 2006 for NVSGSDK by NVIDIA


SwitchToGroupTraverser.h Source File

SwitchToGroupTraverser.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 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvtraverser
00022 {
00024   class SwitchToGroupTraverser : public OptimizeTraverser
00025   {
00026     public:
00028       NVSG_API SwitchToGroupTraverser( void );
00029
00030     protected:
00032       NVSG_API virtual ~SwitchToGroupTraverser( void );
00033
00035       NVSG_API virtual void doApply( const nvsg::Scene * scene
00036                                    );
00037
00039
00040       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00041                                                    );
00042
00044       NVSG_API virtual void handleBillboard( const nvsg::Billboard *p
00045                                            );
00046
00048       NVSG_API virtual void handleGroup( const nvsg::Group *p
00049                                        );
00050
00052       NVSG_API virtual void handleLOD( const nvsg::LOD *p
00053                                      );
00054
00055 #if defined( _DEBUG )
00056
00057
00058       NVSG_API virtual void handleSwitch( const nvsg::Switch *p
00059                                         );
00060 #endif
00061
00063       NVSG_API virtual void handleTransform( const nvsg::Transform *p
00064                                            );
00065
00066     private:
00067       const nvsg::Group * createGroupFromSwitch( const nvsg::Switch * pSwitch );
00068       void                replaceSwitches( const nvsg::Group *p );
00069   };
00070 }
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


SWMRSync.h File Reference

#include "nvsgcommon.h"
#include "nvsgwindefs.h"
#include <windows.h>
#include <winbase.h>
#include <pthread.h>

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 Fri Aug 4 08:35:50 2006 for NVSGSDK by NVIDIA


SWMRSync.h Source File

SWMRSync.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(_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
00032 namespace nvutil {
00033
00034 class ISWMRSync;
00035
00036 NVSG_API extern void EnableLocking();
00037 NVSG_API extern bool WaitToWrite(const ISWMRSync * obj);
00038 NVSG_API extern void DoneWriting(const ISWMRSync * obj);
00039 NVSG_API extern bool WaitToRead(const ISWMRSync * obj);
00040 NVSG_API extern void DoneReading(const ISWMRSync * obj);
00041
00042
00043 // Single write, multiple read synchronization class.
00044 class SWMRSync
00045 {
00046 public:
00047
00049   SWMRSync(void);
00051   ~SWMRSync(void);
00052
00053   NVSG_API bool lockExclusive() const;
00054   NVSG_API void unlockExclusive() const;
00055   NVSG_API bool lockShared() const;
00056   NVSG_API void unlockShared() const;
00057
00058 private:
00059   void enterCriticalSection() const;
00060   void leaveCriticalSection() const;
00061   void yield() const;
00062
00063 #if defined(_WIN32)
00064   typedef CRITICAL_SECTION SWMRCriticalSection;
00065 #elif defined(LINUX)
00066   typedef pthread_mutex_t  SWMRCriticalSection;
00067 #endif
00068
00069   mutable SWMRCriticalSection m_cs; // thread synchronization object
00070   mutable int m_sharedLockCount; // accessed only when inside critical section
00071 };
00072
00074 class ISWMRSync
00075 {
00076 public:
00078
00079   NVSG_API bool waitToWrite() const;
00081   NVSG_API void doneWriting() const;
00083
00084   NVSG_API bool waitToRead()  const;
00086   NVSG_API void doneReading() const;
00087
00088 protected:
00089   ISWMRSync();
00090   ISWMRSync(const ISWMRSync&);
00091   ISWMRSync& operator=(const ISWMRSync&);
00092   virtual ~ISWMRSync();
00093
00094 private:
00095   SWMRSync * m_lock; // implementation of locking
00096 };
00097
00098 inline void SWMRSync::enterCriticalSection() const
00099 {
00100 #if defined(_WIN32)
00101     EnterCriticalSection(&m_cs);
00102 #elif defined(LINUX)
00103     pthread_mutex_lock(&m_cs);
00104 #endif
00105 }
00106
00107 inline void SWMRSync::leaveCriticalSection() const
00108 {
00109 #if defined(_WIN32)
00110     LeaveCriticalSection(&m_cs);
00111 #elif defined(LINUX)
00112     pthread_mutex_unlock(&m_cs);
00113 #endif
00114 }
00115
00116 inline void SWMRSync::yield() const
00117 {
00118 #if defined(_WIN32)
00119     Sleep(0);
00120 #elif defined(LINUX)
00121     sched_yield();
00122 #endif
00123 }
00124
00125 inline bool ISWMRSync::waitToWrite() const
00126 {
00127   NVSG_TRACE();
00128   NVSG_ASSERT(m_lock);
00129   return m_lock->lockExclusive();
00130 }
00131
00132 inline void ISWMRSync::doneWriting() const
00133 {
00134   NVSG_TRACE();
00135   NVSG_ASSERT(m_lock);
00136   m_lock->unlockExclusive();
00137 }
00138
00139 inline bool ISWMRSync::waitToRead()  const
00140 {
00141   NVSG_TRACE();
00142   NVSG_ASSERT(m_lock);
00143   return m_lock->lockShared();
00144 }
00145
00146 inline void ISWMRSync::doneReading() const
00147 {
00148   NVSG_TRACE();
00149   NVSG_ASSERT(m_lock);
00150   m_lock->unlockShared();
00151 }
00152
00154
00169 template<typename T>
00170 inline T * beginEdit( const T * obj
00171                     )
00172 {
00173   NVSG_ASSERT(obj); // undefined behavior if this fires
00174   obj->waitToWrite();
00175   return const_cast<T *>(obj);
00176 }
00177
00179
00193 template<typename T>
00194 inline const T * endEdit(T *& obj
00195                         )
00196 {
00197   NVSG_ASSERT(obj); // undefined behavior if this fires
00198   const T* cobj = obj;
00199   cobj->doneWriting();
00200   obj = NULL; // force undefined behavior if accessed after endEdit
00201   return( cobj );
00202 }
00203
00204 #if !defined(DOXYGEN_IGNORE)
00205 // this specialization detects wrong usage of endEdit at compile time
00206 template<typename T>
00207 inline const T * endEdit(const T *& obj)
00208 { // !!! must not call endEdit with a 'pointer to const' !!!
00209
00210   // generate a compiler error
00211   T * p=obj;
00212 }
00213 #endif // !DOXYGEN_IGNORE
00214
00215 } // namespace nvutil
00216
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


TextureAttribute.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Plane3f.h"
#include "nvmath/Trafo.h"
#include "nvmath/Vec4f.h"
#include "nvsg/StateAttribute.h"
#include <map>
#include <string>

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 Fri Aug 4 08:35:51 2006 for NVSGSDK by NVIDIA


TextureAttribute.h Source File

TextureAttribute.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/Plane3f.h"
00017 #include "nvmath/Trafo.h" // uses Trafo
00018 #include "nvmath/Vec4f.h" // uses Vec4f
00019 #include "nvsg/StateAttribute.h" // base class definition
00020
00021 #include <map> // uses std::map
00022 #include <string> // uses std::string
00023
00024 namespace nvsg
00025 {
00026   class TextureAttribute;
00027
00029   typedef enum
00030   {
00031     TCA_S = 0
00032   , TCA_T
00033   , TCA_R
00034   , TCA_Q
00035   } TexCoordAxis;
00036
00038   typedef enum
00039   {
00040     TEM_REPLACE = 0
00041   , TEM_MODULATE
00042   , TEM_DECAL
00043   , TEM_BLEND
00044   , TEM_ADD
00045   } TextureEnvMode;
00046
00048   typedef enum
00049   {
00050     TGM_OFF           = -1
00051   , TGM_OBJECT_LINEAR
00052   , TGM_EYE_LINEAR
00053   , TGM_SPHERE_MAP
00054   , TGM_REFLECTION_MAP
00055   , TGM_NORMAL_MAP
00056   } TexGenMode;
00057
00059   typedef enum
00060   {
00061     TGLP_OBJECT = 0
00062   , TGLP_EYE
00063   , TGLP_OBJECT_AND_EYE
00064   } TexGenLinearPlane;
00065
00067   typedef enum
00068   {
00069     TWCA_S = 0
00070   , TWCA_T
00071   , TWCA_R
00072   } TexWrapCoordAxis;
00073
00075   typedef enum
00076   {
00077     TWM_REPEAT = 0
00078   , TWM_CLAMP
00079   , TWM_MIRROR
00080   } TextureWrapMode;
00081
00083   typedef enum
00084   {
00085     TFM_MIN_NEAREST = 0
00086   , TFM_MIN_BILINEAR
00087   , TFM_MIN_TRILINEAR
00088   } TextureMinFilterMode;
00089
00091   typedef enum
00092   {
00093     TFM_MAG_NEAREST = 0
00094   , TFM_MAG_BILINEAR
00095   } TextureMagFilterMode;
00096
00097   class TextureAttributeItem;
00098   class TextureImage;
00099
00101   class TextureAttributeItemData : public nvutil::RCObject
00102   {
00103       friend class TextureAttributeItem;
00104     public:
00106
00107       NVSG_API TextureAttributeItemData(const TextureAttributeItemData& rhs);
00108
00109     private:
00110       // instantiation on stack is not permitted.
00111       TextureAttributeItemData();
00112       ~TextureAttributeItemData();
00113       // assignment also not permitted
00114       TextureAttributeItemData& operator=(const TextureAttributeItemData& rhs) {}
00115
00116       nvmath::Vec4f         m_borderColor;
00117       nvmath::Vec4f         m_envColor;
00118       TextureEnvMode        m_envMode;            // enum environment mode to use with rasterization
00119       TextureMagFilterMode  m_magFilterMode;
00120       TextureMinFilterMode  m_minFilterMode;
00121       nvmath::Trafo         m_trafo;              // texture coordinate transformation
00122       TextureWrapMode       m_wrapMode[3];
00123       TexGenMode            m_texGenMode[4];
00124       nvmath::Vec4f         m_texGenPlane[2][4];
00125   };
00126
00128
00133   class TextureAttributeItem : public Object
00134   {
00135     friend class TextureAttribute;
00136
00137   public:
00138     // accessible instantiation functions
00139
00141
00142     NVSG_API static const TextureAttributeItem * create( void );
00143
00145
00147     NVSG_API static const TextureAttributeItem * createFromBase( const Object &rhs );
00148
00150
00151     NVSG_API virtual const TextureAttributeItem * clone( void ) const;
00152
00154
00155     NVSG_API virtual bool isDataShared( void ) const;
00156
00158
00159     NVSG_API virtual DataID getDataID( void ) const;
00160
00162
00163     NVSG_API bool getTextureFileName( std::string& filename
00165                                     ) const;
00166
00168
00170     NVSG_API const std::string& getTextureFileName() const;
00171
00173
00176
00179
00183
00186
00197
00202
00203
00206
00208
00214
00220
00223
00224
00227
00231
00232
00235
00239
00240
00243
00247
00248
00250
00253
00255
00258
00259
00262
00263
00266
00268
00271
00272
00275
00277
00280
00281
00284
00286
00289
00298
00302
00304
00309
00313
00321
00327
00333
00334
00339
00342
00345
00346
00353
00356
00359
00362
00364
00367
00371
00405
00412
00421
00422
00425
00426
00429
00430
00433
00436
00441
00444
00448
00454
00457
00464
00467
00477
00480
00483
00487
00490
00491
00498
00501
00504
00507
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


TextureImage.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvsg/DAL.h"
#include "nvutil/RCObject.h"
#include "nvutil/SWMRSync.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

Go to the source code of this file.

Namespaces

namespace | nvsg

Defines

#define | VERTICAL_CROSS_FORMAT(w, h) ((3*(h))==(4*(w)))

Detailed Description

Generated on Fri Aug 4 08:35:52 2006 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 "nvmath/nvmath.h"
00017 #include "nvsg/DAL.h"
00018 #include "nvutil/RCObject.h"
00019 #include "nvutil/SWMRSync.h"
00020 #include "nvutil/BitMask.h"
00021 #include "nvutil/PlugIn.h"
00022 #include <math.h>
00023 #include <vector>
00024 #include <map>
00025 #include <string>
00026
00027 // VERTICAL_CROSS_FORMAT(w,h) macro evaluates to true if
00028 // width and height comply with vertical cross format:
00029 //
00030 //        ___
00031 //       |   |
00032 // 3  ___|___|____
00033 //   |   |   |    |
00034 // 2 |___|___|____|
00035 //       |   |          3xheight == 4xwidth
00036 // 1     |___|
00037 //       |   |
00038 // 0     |___|
00039 //
00040 //     0   1   2
00041 #define VERTICAL_CROSS_FORMAT(w,h) ((3*(h))==(4*(w)))
00042
00043 namespace nvsg
00044 {
00045   class ScaleFilter;
00046   class TextureLoader;
00047
00049   class TextureImage : public nvutil::RCObject  // reference counted
00050                      , public nvutil::ISWMRSync // lockable
00051                      , public nvsg::DALHost   // can host DAL data
00052   {
00053   public:
00054
00056     enum PixelFormat
00057     {
00058       IMG_UNKNOWN_FORMAT = -1
00059     , IMG_COLOR_INDEX = 0
00060     , IMG_RGB
00061     , IMG_RGBA
00062     , IMG_BGR
00063     , IMG_BGRA
00064     , IMG_LUMINANCE
00065     , IMG_LUMINANCE_ALPHA
00066     , IMG_NUM_FORMATS
00067     };
00068
00070     enum PixelDataType
00071     {
00072       IMG_UNKNOWN_TYPE = -1
00073     , IMG_BYTE = 0
00074     , IMG_UNSIGNED_BYTE
00075     , IMG_SHORT
00076     , IMG_UNSIGNED_SHORT
00077     , IMG_INT
00078     , IMG_UNSIGNED_INT
00079     , IMG_FLOAT
00080     , IMG_HALF
00081     , IMG_NUM_TYPES
00082     };
00083
00085     enum
00086     {
00087       F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD = BIT0
00089     , F_IMAGE_STREAM = BIT2
00091     , F_SCALE_FILTER_BOX = 0
00092     , F_SCALE_FILTER_TRIANGLE = BIT7
00093     , F_SCALE_FILTER_BELL = BIT8
00094     , F_SCALE_FILTER_BSPLINE = BIT7 | BIT8
00095     , F_SCALE_FILTER_LANCZOS3 = BIT9
00096     , F_SCALE_FILTER_MASK = BIT7 | BIT8 | BIT9
00097     };
00098
00100
00119     NVSG_API static const TextureImage * create( unsigned int flags = 0
00120                                                );
00121
00123
00135     NVSG_API static const TextureImage * createFromFile( const std::string& filename
00136                                                        , unsigned int flags = 0
00137                                                        );
00138
00140
00141     NVSG_API const TextureImage * clone() const;
00142
00144
00178     NVSG_API size_t createImage( unsigned int    width
00179                                , unsigned int    height
00180                                , unsigned int    depth
00181                                , unsigned int    bpp
00182                                , PixelFormat     format
00183                                , PixelDataType   type
00184                                , const void    * pixels
00185                                , const std::vector<const void*>& mipmaps = std::vector<const void*>()
00187                                );
00188
00190
00191     NVSG_API void releaseImages();
00192
00194
00205     NVSG_API void incrementMipmapUseCount();
00206
00208
00218     NVSG_API void decrementMipmapUseCount();
00219
00221
00229     NVSG_API size_t getMipmapUseCount() const;
00230
00232
00240     NVSG_API bool createMipmaps();
00241
00243
00244     NVSG_API size_t getNumberOfImages() const;
00245
00247
00250     NVSG_API size_t getNumberOfMipmaps( size_t image=0
00251                                       ) const;
00252
00254
00263     NVSG_API PixelFormat getFormat( size_t image=0
00264                                   , size_t mipmap=0
00265                                   ) const;
00266
00268
00277     NVSG_API PixelDataType getType( size_t image=0
00278                                   , size_t mipmap=0
00279                                   ) const;
00280
00282
00290     NVSG_API unsigned int getWidth( size_t image=0
00291                                   , size_t mipmap=0
00292                                   ) const;
00293
00295
00303     NVSG_API unsigned int getHeight( size_t image=0
00304                                    , size_t mipmap=0
00305                                    ) const;
00306
00308
00316     NVSG_API unsigned int getDepth( size_t image=0
00317                                   , size_t mipmap=0
00318                                   ) const;
00319
00321
00329     NVSG_API unsigned int getBytesPerPixel( size_t image=0
00330                                           , size_t mipmap=0
00331                                           ) const;
00332
00334
00342     NVSG_API unsigned int getBytesPerScanLine( size_t image=0
00343                                              , size_t mipmap=0
00344                                              ) const;
00345
00347
00355     NVSG_API unsigned int getBytesPerImage( size_t image=0
00356                                           , size_t mipmap=0
00357                                           ) const;
00358
00360
00368     NVSG_API const void * getPixels( size_t image = 0
00369                                    , size_t mipmap = 0
00370                                    ) const;
00371
00373     NVSG_API unsigned int getUnpackAlignment() const;
00374
00376
00383     NVSG_API bool scale( size_t image
00384                        , unsigned int width
00385                        , unsigned int Height = 1
00386                        , unsigned int depth = 1
00387                        );
00388
00390
00391     NVSG_API bool is1D()            const;
00392
00394
00395     NVSG_API bool is2D()            const;
00396
00398
00399     NVSG_API bool is3D()            const;
00400
00402
00404
00407
00408
00411
00413
00416
00420
00423
00434
00437
00438
00441
00445
00448
00449
00452
00453
00456
00457
00461
00462
00675
00691
00695
00697
00700
00701
00706
00708
00712
00713
00716
00717
00732
00734
00738
00739
00742
00743
00758
00762
00766
00767
00770
00772
00781
00785
00789
00790
00793
00795
00804
00807
00811
00812
00815
00817
Generated on Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


Tools.h File Reference

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

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 Fri Aug 4 08:35:53 2006 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 namespace nvutil
00019 {
00020
00022
00037   extern NVSG_API bool FindFile( const std::string &mask
00038                                , const std::vector<std::string> &searchPaths
00039                                , std::vector<std::string> &results
00040                                , bool recursive=false
00041                                );
00042
00044
00046   extern NVSG_API bool FindFileFirst( const std::string &mask
00047                                     , const std::vector<std::string> &searchPaths
00048                                     , std::string &nameOut
00049                                     , bool recursive=false
00050                                     );
00051
00053   extern NVSG_API bool FileExists( const std::string &filepath  //<! Input (path+)filename.
00054                                  );
00055
00057
00059   extern NVSG_API void GetFileNameFromPath( const std::string& path
00060                                           , std::string& fname
00061                                           );
00063
00065   extern NVSG_API void GetFileExtFromPath( const std::string& path
00066                                          , std::string& fext
00067                                          );
00069
00071   extern NVSG_API void GetDirFromPath( const std::string& path
00072                                      , std::string& dir
00073                                      );
00075
00077   extern NVSG_API void GetDrvFromPath( const std::string& path
00078                                      , std::string& drv
00079                                      );
00081
00083   extern NVSG_API void GetDrvAndDirFromPath(const std::string& path
00084                                            , std::string& dir
00085                                            );
00086 #if defined(_WIN32)
00087
00088
00090   extern NVSG_API void GetModulePath( const std::string& module
00091                                     , std::string& path
00092                                     );
00093 #else
00094
00095
00097   extern NVSG_API void GetModulePath( std::string& path );
00098 #endif
00099
00100 #if defined(_WIN32)
00101
00102
00104   extern NVSG_API void GetModulePath( const HMODULE hModule
00105                                     , std::string& path
00106                                     );
00107 #endif
00108
00110
00113   extern NVSG_API bool GetCurrentDir( std::string& path
00114                                     );
00115
00116   template<typename T>  T Maximum( T a, T b, T c )
00117   {
00118     return( ( a < b ) ? std::max( b, c ) : std::max( a, c ) );
00119   }
00120
00121   template<typename T>  T Minimum( T a, T b, T c )
00122   {
00123     return( ( a < b ) ? std::min( a, c ) : std::min( b, c ) );
00124   }
00125
00127
00130   extern NVSG_API std::string SetCurrentDir( const std::string& dir
00131                                       );
00132
00133 } // namespace nvutil
Generated on Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:36:02 2006 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 Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


Trackball.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vec2f.h"
#include "nvmath/Vec3f.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 Fri Aug 4 08:36:03 2006 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
00017 #include "nvmath/Vec2f.h"
00018 #include "nvmath/Vec3f.h"
00019
00020 namespace nvutil
00021 {
00022
00024
00029   class Trackball
00030   {
00031     public:
00033       Trackball(void);
00034
00036       virtual ~Trackball(void);
00037
00039
00048       void  apply( const nvmath::Vec2f &p0
00049                  , const nvmath::Vec2f &p1
00050                  , nvmath::Vec3f & axis
00051                  , float & rad
00052                  );
00053
00055
00060       void  setSize( float size
00061                    );
00062
00064
00066       float getSize( void );
00067
00068     protected:
00070
00073       float projectOntoTBSphere( const nvmath::Vec2f & p );
00074
00075       float m_tbsize;
00076   };
00077
00078   inline  void  Trackball::setSize( float size )
00079   {
00080     NVSG_ASSERT( m_tbsize > 0.f );
00081     m_tbsize = size;
00082   }
00083
00084   inline float Trackball::getSize( void )
00085   {
00086     return( m_tbsize );
00087   }
00088
00089 } //  namespace nvui
Generated on Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:36:04 2006 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     };
00070
00086     NVSG_API virtual bool updateFrame();
00087
00092     NVSG_API virtual bool isActive();
00093
00100     NVSG_API void keyDown( UINT key  );
00101
00108     NVSG_API void keyUp( UINT key );
00109
00120     NVSG_API void mouseButtonDown( UINT btn, int x, int y );
00121
00132     NVSG_API void mouseButtonUp( UINT btn, int x, int y );
00133
00140     NVSG_API void mouseMotion( int x, int y );
00141
00148     NVSG_API void reset();
00149
00158     NVSG_API bool isDolly();
00159
00168     NVSG_API bool isPan();
00169
00177     NVSG_API bool isOrbit();
00178
00179   protected:
00180     static NVSG_API const UINT DOLLY1;
00181     static NVSG_API const UINT DOLLY2;
00182     static NVSG_API const UINT PAN1;
00183     static NVSG_API const UINT PAN2;
00184     static NVSG_API const UINT ORBIT;
00185
00186     nvui::MouseInput m_mouseInput;
00187     nvui::KeyInput   m_keyInput;
00188
00189   private:
00190     nvutil::Trackball m_trackball;
00191     nvui::MouseInput m_miLast;
00192     int m_trueX, m_trueY;
00193
00194     // do the manipulations - retval true means there was
00195     // an update so a redraw makes sense
00196     bool orbit();
00197     bool pan();
00198     bool dolly();
00199   };
00200 } // namespace nvui
Generated on Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:36:05 2006 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
00194   private:
00195     nvutil::Trackball m_trackball;  // Trackball object that does all the calculations
00196     int m_trueX, m_trueY;
00197
00198     // do the manipulations - retval true means there was
00199     // an update so a redraw makes sense
00200     bool pan();
00201     bool rotate();
00202     bool dolly();
00203   };
00204 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


Trafo.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Mat44f.h"
#include "nvmath/Quatf.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 Fri Aug 4 08:36:06 2006 for NVSGSDK by NVIDIA


Trafo.h Source File

Trafo.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/Mat44f.h"
00017 #include "nvmath/Quatf.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
00055
00056       NVSG_API Mat44f getMatrix( void ) const;
00057
00059
00060       NVSG_API Mat44f getInverse( void ) const;
00061
00063       NVSG_API void setCenter( const Vec3f &center
00064                              );
00065
00067       NVSG_API void setIdentity( void );
00068
00070       NVSG_API void setOrientation( const Quatf &orientation
00071                                   );
00072
00074       NVSG_API void setScaleOrientation( const Quatf &scaleOrientation
00075                                        );
00076
00078       NVSG_API void setScaling( const Vec3f &scaling
00079                               );
00080
00082       NVSG_API void setTranslation( const Vec3f &translation
00083                                   );
00084
00086
00087       NVSG_API void setMatrix( const Mat44f &matrix
00088                              );
00089
00091       NVSG_API Trafo & operator=( const Trafo &rhs
00092                        );
00093
00095
00096       NVSG_API bool operator==( const Trafo &t
00097                               ) const;
00098
00099     private:
00100       Vec3f   m_center;
00101       Quatf   m_orientation;
00102       Quatf   m_scaleOrientation;
00103       Vec3f   m_scaling;
00104       Vec3f   m_translation;
00105   };
00106
00107   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00108   // non-member functions
00109   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00112   NVSG_API Trafo lerp( float alpha
00113                      , const Trafo &t0
00114                      , const Trafo &t1
00115                      );
00116
00117   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00118   // inlines
00119   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00120   inline const Vec3f & Trafo::getCenter( void ) const
00121   {
00122     NVSG_TRACE();
00123     return( m_center );
00124   }
00125
00126   inline const Quatf & Trafo::getOrientation( void ) const
00127   {
00128     NVSG_TRACE();
00129     return( m_orientation );
00130   }
00131
00132   inline const Quatf & Trafo::getScaleOrientation( void ) const
00133   {
00134     NVSG_TRACE();
00135     return( m_scaleOrientation );
00136   }
00137
00138   inline const Vec3f & Trafo::getScaling( void ) const
00139   {
00140     NVSG_TRACE();
00141     return( m_scaling );
00142   }
00143
00144   inline const Vec3f & Trafo::getTranslation( void ) const
00145   {
00146     NVSG_TRACE();
00147     return( m_translation );
00148   }
00149
00150   inline void Trafo::setCenter( const Vec3f &center )
00151   {
00152     NVSG_TRACE();
00153     m_center = center;
00154   }
00155
00156   inline void Trafo::setOrientation( const Quatf &orientation )
00157   {
00158     NVSG_TRACE();
00159     NVSG_ASSERT( isNormalized( orientation, FLT_EPSILON ) );
00160     m_orientation = orientation;
00161   }
00162
00163   inline void Trafo::setScaleOrientation( const Quatf &scaleOrientation )
00164   {
00165     NVSG_TRACE();
00166     NVSG_ASSERT( isNormalized( scaleOrientation ) );
00167     m_scaleOrientation = scaleOrientation;
00168   }
00169
00170   inline void Trafo::setScaling( const Vec3f &scaling )
00171   {
00172     NVSG_TRACE();
00173     m_scaling = scaling;
00174   }
00175
00176   inline void Trafo::setTranslation( const Vec3f &translation )
00177   {
00178     NVSG_TRACE();
00179     m_translation = translation;
00180   }
00181
00182 }
Generated on Fri Aug 4 08:33:10 2006 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 Fri Aug 4 08:36:07 2006 for NVSGSDK by NVIDIA


Transform.h Source File

Transform.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 "nvmath/Trafo.h"
00018 #include "nvsg/Group.h"
00019
00020 namespace nvsg
00021 {
00028   class Transform : public Group
00029   {
00030     public:
00034       NVSG_API static const Transform * create( void );
00035
00043       NVSG_API static const Transform * createFromBase( const Group & rhs );
00044
00048       NVSG_API virtual const Transform * clone( void ) const;
00049
00053       NVSG_API const nvmath::Trafo & getTrafo( void ) const;
00054
00060       NVSG_API virtual void setTrafo( const nvmath::Trafo & trafo );
00061
00068       NVSG_API Transform & operator=(const Transform & rhs);
00069
00078       NVSG_API virtual bool isEquivalent( const Object * p
00079                                         , bool ignoreNames
00080                                         , bool deepCompare ) const;
00081
00082     protected:
00085       NVSG_API Transform(void);
00086
00092       NVSG_API Transform( const Group &rhs );
00093
00097       NVSG_API Transform( const Transform &rhs );
00098
00103       NVSG_API virtual ~Transform(void);
00104
00110       NVSG_API virtual nvmath::Sphere3f calculateBoundingSphere( void ) const;
00111
00112     private:
00113       nvmath::Trafo m_trafo;
00114   };
00115
00116   inline const nvmath::Trafo & Transform::getTrafo( void ) const
00117   {
00118     return( m_trafo );
00119   }
00120 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


TransformCombineTraverser.h File Reference

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

Include dependency graph for TransformCombineTraverser.h:

Include dependency graph

Go to the source code of this file.

Namespaces

namespace nvtraverser

Detailed Description

Generated on Fri Aug 4 08:36:08 2006 for NVSGSDK by NVIDIA


TransformCombineTraverser.h Source File

TransformCombineTraverser.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
00017 #include "nvsgcommon.h"
00018
00019 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvtraverser
00022 {
00024
00028   class TransformCombineTraverser : public OptimizeTraverser
00029   {
00030     public:
00032       NVSG_API TransformCombineTraverser( void );
00033
00034     protected:
00036       NVSG_API virtual ~TransformCombineTraverser( void );
00037
00039
00040       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00041                                                    );
00042
00044
00045       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p
00046                                            );
00047
00049       NVSG_API virtual void handleGroup( const nvsg::Group * p
00050                                        );
00051
00053
00054       NVSG_API virtual void handleTransform( const nvsg::Transform * p
00055                                            );
00056
00057     private:
00058       void combineTransforms( const nvsg::Group *p );
00059   };
00060
00061 }
Generated on Fri Aug 4 08:33:10 2006 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 Fri Aug 4 08:36:09 2006 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 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


TransformStack.h File Reference

#include "nvsgcommon.h"
#include <stack>
#include "nvmath/Mat44f.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 Fri Aug 4 08:36:11 2006 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 "nvsgcommon.h"
00016
00017 #include <stack>
00018 #include "nvmath/Mat44f.h"
00019
00020 namespace nvutil
00021 {
00023
00039   class TransformStack
00040   {
00041     public:
00043
00044       TransformStack();
00045
00046     public:
00048       NVSG_API const nvmath::Mat44f    getClipToModel( void )  const;
00049
00051       NVSG_API const nvmath::Mat44f  & getClipToView( void )   const;
00052
00054       NVSG_API const nvmath::Mat44f    getModelToClip( void )  const;
00055
00057       NVSG_API const nvmath::Mat44f    getModelToView( void )  const;
00058
00060       NVSG_API const nvmath::Mat44f  & getModelToWorld( void ) const;
00061
00063       NVSG_API const nvmath::Mat44f  & getViewToClip( void )   const;
00064
00066       NVSG_API const nvmath::Mat44f    getViewToModel( void )  const;
00067
00069       NVSG_API const nvmath::Mat44f  & getViewToWorld( void )  const;
00070
00072       NVSG_API const nvmath::Mat44f  & getWorldToModel( void ) const;
00073
00075       NVSG_API const nvmath::Mat44f  & getWorldToView( void )  const;
00076
00078       NVSG_API size_t    getStackDepth( void )   const;
00079
00081       NVSG_API void      popModelToWorld( void );
00082
00084
00085       NVSG_API void      pushModelToWorld( const nvmath::Mat44f &modelWorld
00086                                          , const nvmath::Mat44f &worldModel
00087                                          );
00088
00090
00091       NVSG_API void      setViewToClip( const nvmath::Mat44f &viewClip
00092                                       , const nvmath::Mat44f &clipView
00093                                       );
00094
00096
00097       NVSG_API void      setWorldToView( const nvmath::Mat44f &worldView
00098                                        , const nvmath::Mat44f &viewWorld
00099                                        );
00100
00101     private :
00102       std::stack<nvmath::Mat44f> m_modelWorld;
00103       std::stack<nvmath::Mat44f> m_worldModel;
00104       nvmath::Mat44f        m_worldView;
00105       nvmath::Mat44f        m_viewWorld;
00106       nvmath::Mat44f        m_viewClip;
00107       nvmath::Mat44f        m_clipView;
00108   };
00109
00110
00111   inline  TransformStack::TransformStack()
00112   {
00113     m_modelWorld.push( nvmath::cIdentity44f );
00114     m_worldModel.push( nvmath::cIdentity44f );
00115   }
00116
00117   inline  const nvmath::Mat44f    TransformStack::getClipToModel( void )  const
00118   {
00119     return( m_worldModel.top() * m_viewWorld * m_clipView );
00120   }
00121
00122   inline  const nvmath::Mat44f  & TransformStack::getClipToView( void )   const
00123   {
00124     return( m_clipView );
00125   }
00126
00127   inline  const nvmath::Mat44f    TransformStack::getModelToClip( void )  const
00128   {
00129     return( m_viewClip * m_worldView * m_modelWorld.top() );
00130   }
00131
00132   inline  const nvmath::Mat44f    TransformStack::getModelToView( void )  const
00133   {
00134     return( m_worldView * m_modelWorld.top() );
00135   }
00136
00137   inline  const nvmath::Mat44f  & TransformStack::getModelToWorld( void ) const
00138   {
00139     return( m_modelWorld.top() );
00140   }
00141
00142   inline  const nvmath::Mat44f  & TransformStack::getViewToClip( void )   const
00143   {
00144     return( m_viewClip );
00145   }
00146
00147   inline  const nvmath::Mat44f    TransformStack::getViewToModel( void )  const
00148   {
00149     return( m_worldModel.top() * m_viewWorld );
00150   }
00151
00152   inline  const nvmath::Mat44f  & TransformStack::getViewToWorld( void )  const
00153   {
00154     return( m_viewWorld );
00155   }
00156
00157   inline  const nvmath::Mat44f  & TransformStack::getWorldToModel( void ) const
00158   {
00159     return( m_worldModel.top() );
00160   }
00161
00162   inline  const nvmath::Mat44f  & TransformStack::getWorldToView( void )  const
00163   {
00164     return( m_worldView );
00165   }
00166
00167   inline  size_t  TransformStack::getStackDepth( void ) const
00168   {
00169     NVSG_ASSERT( m_modelWorld.size() == m_worldModel.size() );
00170     return( m_modelWorld.size() );
00171   }
00172
00173   inline  void  TransformStack::popModelToWorld( void )
00174   {
00175     m_modelWorld.pop();
00176     m_worldModel.pop();
00177   }
00178
00179   inline  void  TransformStack::pushModelToWorld( const nvmath::Mat44f &modelWorld, const nvmath::Mat44f &worldModel )
00180   {
00181     NVSG_TRACE();
00182     NVSG_TRACE_MAT44F(modelWorld);
00183     NVSG_TRACE_MAT44F(worldModel);
00184     NVSG_TRACE_MAT44F((modelWorld*worldModel));
00185     m_modelWorld.push( m_modelWorld.top() * modelWorld );
00186     m_worldModel.push( worldModel * m_worldModel.top() );
00187   }
00188
00189   inline  void  TransformStack::setViewToClip( const nvmath::Mat44f &viewClip, const nvmath::Mat44f &clipView )
00190   {
00191     NVSG_TRACE();
00192     NVSG_TRACE_MAT44F(viewClip);
00193     NVSG_TRACE_MAT44F(clipView);
00194     m_viewClip = viewClip;
00195     m_clipView = clipView;
00196   }
00197
00198   inline  void  TransformStack::setWorldToView( const nvmath::Mat44f &worldView, const nvmath::Mat44f &viewWorld )
00199   {
00200     NVSG_TRACE();
00201     NVSG_TRACE_MAT44F(worldView);
00202     NVSG_TRACE_MAT44F(viewWorld);
00203     m_worldView = worldView;
00204     m_viewWorld = viewWorld;
00205   }
00206 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


Traverser.h File Reference

#include <stack>
#include "nvsgcommon.h"
#include "nvsg/Object.h"
#include "nvutil/MemFunTbl.h"
#include "nvutil/SWMRSync.h"
#include "nvutil/ProblemLog.h"

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 | nvmath
namespace | nvsg
namespace | nvtraverser

Detailed Description

Generated on Fri Aug 4 08:36:12 2006 for NVSGSDK by NVIDIA


Traverser.h Source File

Traverser.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
00017 #include "nvsgcommon.h"
00018 #include "nvsg/Object.h"
00019 #include "nvutil/MemFunTbl.h"
00020 #include "nvutil/SWMRSync.h"
00021 #include "nvutil/ProblemLog.h"
00022
00023 // forward declarations
00024 namespace nvmath
00025 {
00026   class Trafo;
00027 }
00028 namespace nvsg
00029 {
00030   class AnimatedQuads;
00031   class AnimatedTransform;
00032   class AnimatedTriangles;
00033   class Billboard;
00034   class Bitmap;
00035   class BlendAttribute;
00036   class Camera;
00037   class CgFx;
00038   class CullData;
00039   class DepthAttribute;
00040   class DirectedLight;
00041   class Drawable;
00042   class FaceAttribute;
00043   class GeoNode;
00044   class Group;
00045   class HighlightBox;
00046   class HighlightEdges;
00047   class HighlightObject;
00048   class LightSource;
00049   class LineAttribute;
00050   class Lines;
00051   class LineStrips;
00052   class LOD;
00053   class MapArray;
00054   class MapElement;
00055   class MapList;
00056   class MapMatrix;
00057   class Material;
00058   class Node;
00059   class ParallelCamera;
00060   class PerspectiveCamera;
00061   class PointAttribute;
00062   class PointLight;
00063   class Points;
00064   class PrimitiveSet;
00065   class QuadMeshes;
00066   class Quads;
00067   class QuadStrips;
00068   class Scene;
00069   class Shape;
00070   class SkinnedTriangles;
00071   class SpotLight;
00072   class StateSet;
00073   class StatePass;
00074   class StateVariant;
00075   class Switch;
00076   class TextureAttribute;
00077   class TextureAttributeItem;
00078   class Transform;
00079   class Triangles;
00080   class TriFans;
00081   class TriStrips;
00082   class VertexAttributeSet;
00083   class ViewState;
00084   class VNVector;
00085   template<typename T> class FramedAnimation;
00086   template<typename T> class LinearInterpolatedAnimation;
00087 }
00088
00089 namespace nvtraverser
00090 {
00091
00093
00107 class Traverser : public nvutil::RCObject
00108 {
00109 public:
00110
00112
00124   NVSG_API void apply( const nvsg::Scene     * scene
00125                      );
00126
00128
00129   NVSG_API void interruptTraversal();
00130
00135   NVSG_API bool wasTraversalInterrupted();
00136
00138
00142   NVSG_API const nvutil::ProblemLogList & getProblems();
00143
00144 protected:
00145
00147
00149   NVSG_API Traverser( bool readOnly = true );
00150
00152   NVSG_API virtual ~Traverser(void);
00153
00155
00162   NVSG_API virtual void  doApply(const nvsg::Scene * scene
00163                                 );
00164
00180   NVSG_API virtual bool preApply(const nvsg::Node * root);
00181
00194   NVSG_API virtual void postApply(const nvsg::Node * root);
00195
00197
00214   template<typename HandlerType>
00215   void addObjectHandler( unsigned int objectCode
00216                        , HandlerType handler
00217                        );
00218
00220
00224   void traverseObject( const nvsg::Object* object
00225                      );
00226
00228
00233   template <typename T>
00234   void traverseObject( const nvsg::Object* object
00235                      , T arg
00236                      );
00237
00238   //
00239   // Routines to handle concrete Node objects while traversing the tree
00240   //
00241
00243
00248   NVSG_API virtual void handleBillboard( const nvsg::Billboard * p
00249                                        );
00250
00252
00257   NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p
00258                                      );
00259
00261
00268   NVSG_API virtual void handleGroup( const nvsg::Group * p
00269                                    );
00270
00272
00277   NVSG_API virtual void handleLOD( const nvsg::LOD * p
00278                                  );
00279
00281
00286   NVSG_API virtual void handleSwitch( const nvsg::Switch * p
00287                                     );
00288
00290
00295   NVSG_API virtual void handleTransform( const nvsg::Transform * p
00296                                        );
00297
00299
00304   NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform * p
00305                                                );
00306
00308
00313   NVSG_API virtual void handleDirectedLight( const nvsg::DirectedLight * p
00314                                            );
00315
00317
00322   NVSG_API virtual void handlePointLight( const nvsg::PointLight * p
00323                                         );
00324
00326
00331   NVSG_API virtual void handleSpotLight( const nvsg::SpotLight * p
00332                                        );
00333
00334   //
00335   // Routines to handle concrete Drawable objects while traversing the tree
00336   //
00337
00339
00344   NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes * p
00345     );
00346
00348
00353   NVSG_API virtual void handleQuads( const nvsg::Quads * p
00354                                    );
00355
00357
00362   NVSG_API virtual void handleAnimatedQuads( const nvsg::AnimatedQuads * p
00363                                            );
00364
00366
00371   NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips * p
00372                                         );
00373
00375
00380   NVSG_API virtual void handleTriangles( const nvsg::Triangles * p
00381                                        );
00382
00384
00389   NVSG_API virtual void handleAnimatedTriangles( const nvsg::AnimatedTriangles * p
00390                                                );
00391
00393
00398   NVSG_API virtual void handleSkinnedTriangles( const nvsg::SkinnedTriangles * p
00399                                               );
00400
00402
00407   NVSG_API virtual void handleTriFans( const nvsg::TriFans * p
00408                                      );
00409
00411
00416   NVSG_API virtual void handleTriStrips( const nvsg::TriStrips * p
00417                                        );
00418
00420
00425   NVSG_API virtual void handleLines( const nvsg::Lines * p
00426                                    );
00427
00429
00434   NVSG_API virtual void handleLineStrips( const nvsg::LineStrips * p
00435                                         );
00436
00438
00443   NVSG_API virtual void handlePoints( const nvsg::Points * p
00444                                     );
00445
00447
00452   NVSG_API virtual void handleShape( const nvsg::Shape * p
00453                                    );
00454
00456
00461   NVSG_API virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *p
00462                                                 );
00463
00464   //
00465   // Routines to handle either a StateSet or concrete StateAttribute objects while traversing the tree
00466   //
00467
00469
00474   NVSG_API virtual void handleStateSet( const nvsg::StateSet * p
00475                                       );
00476
00478
00483   NVSG_API virtual void handleStateVariant( const nvsg::StateVariant *p
00484                                           );
00485
00487
00492   NVSG_API virtual void handleStatePass( const nvsg::StatePass *p
00493                                        );
00494
00496
00501   NVSG_API virtual void handleBitmap( const nvsg::Bitmap * p
00502                                     );
00503
00505
00510   NVSG_API virtual void handleBlendAttribute( const nvsg::BlendAttribute * p
00511                                             );
00512
00514
00519   NVSG_API virtual void handleCgFx( const nvsg::CgFx * p
00520                                   );
00521
00523
00528   NVSG_API virtual void handleDepthAttribute( const nvsg::DepthAttribute * p
00529                                             );
00530
00532
00537   NVSG_API virtual void handleFaceAttribute( const nvsg::FaceAttribute * p
00538                                            );
00539
00541
00546   NVSG_API virtual void handleLineAttribute( const nvsg::LineAttribute * p
00547                                            );
00548
00550
00555   NVSG_API virtual void handleMapArray( const nvsg::MapArray * p
00556                                         );
00557
00559
00564   NVSG_API virtual void handleMapElement( const nvsg::MapElement * p
00565                                         );
00566
00568
00573   NVSG_API virtual void handleMapList( const nvsg::MapList * p
00574                                      );
00575
00577
00582   NVSG_API virtual void handleMapMatrix( const nvsg::MapMatrix * p
00583                                        );
00584
00586
00591   NVSG_API virtual void handleMaterial( const nvsg::Material * p
00592                                       );
00593
00595
00600   NVSG_API virtual void handlePointAttribute( const nvsg::PointAttribute * p
00601                                             );
00602
00604
00609   NVSG_API virtual void handleTextureAttribute( const nvsg::TextureAttribute * p
00610                                               );
00611
00613
00618   NVSG_API virtual void handleTextureAttributeItem( const nvsg::TextureAttributeItem * p
00619                                                   , size_t tu
00620                                                   );
00621
00622   //
00623   // Routines to handle Camera objects while traversing the tree
00624   //
00625
00627
00634   NVSG_API virtual void handleParallelCamera( const nvsg::ParallelCamera * p
00635                                             , const nvsg::Node * root
00636                                             );
00637
00639
00646   NVSG_API virtual void handlePerspectiveCamera( const nvsg::PerspectiveCamera * p
00647                                                , const nvsg::Node * root
00648                                                );
00649
00650   //
00651   // Routines to handle Animation objects while traversing the tree
00652   //
00653
00655
00660   NVSG_API virtual void handleFramedTrafoAnimation( const nvsg::FramedAnimation<nvmath::Trafo> * p
00661                                                   );
00662
00664
00669   NVSG_API virtual void handleFramedVNVectorAnimation( const nvsg::FramedAnimation<nvsg::VNVector> * p
00670                                                      );
00671
00673
00679   NVSG_API virtual void handleLinearInterpolatedTrafoAnimation( const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> * p
00680                                                               );
00681
00683
00689   NVSG_API virtual void handleLinearInterpolatedVNVectorAnimation( const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> * p
00690                                                                  );
00691
00692   //
00693   // Routines to handle Highlight objects while traversing the tree
00694   //
00695
00697
00702   NVSG_API virtual void handleHighlightBox( const nvsg::HighlightBox * p
00703                                           , const nvsg::PrimitiveSet * primitive
00704                                           );
00705
00707
00712   NVSG_API virtual void handleHighlightEdges( const nvsg::HighlightEdges * p
00713                                             , const nvsg::PrimitiveSet * primitive
00714                                             );
00715
00716
00718
00721   NVSG_API virtual bool preTraverseRoot( const nvsg::Camera *p
00722                                        , const nvsg::Node *root
00723                                        );
00724
00726
00728   NVSG_API virtual void postTraverseRoot( const nvsg::Camera *p
00729                                         , const nvsg::Node *root
00730                                         );
00731
00733
00735   NVSG_API virtual bool preTraverseGroup( const nvsg::Group *p
00736                                         );
00737
00739
00741   NVSG_API virtual void postTraverseGroup( const nvsg::Group *p
00742                                          );
00743
00745
00750   NVSG_API virtual bool preTraverseDrawables( const nvsg::GeoNode *p
00751                                             , size_t i
00752                                             );
00753
00755
00758   NVSG_API virtual void postTraverseDrawables( const nvsg::GeoNode *p
00759                                              , size_t i
00760                                              );
00761
00763
00766   NVSG_API virtual bool preTraverseDrawable( const nvsg::Drawable *p
00767                                            );
00768
00770
00772   NVSG_API virtual void postTraverseDrawable( const nvsg::Drawable *p
00773                                             );
00774
00776
00778   NVSG_API virtual void traverseHighlightObject( const nvsg::HighlightObject* p
00779                                                , const nvsg::PrimitiveSet * primitive
00780                                                );
00781
00783
00785   NVSG_API virtual void traverseLight( const nvsg::LightSource * p
00786                                      );
00787
00789
00791   NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * p
00792                                             );
00793
00795   NVSG_API virtual void preTraverseMap( const nvsg::MapArray * p
00796                                       , size_t index
00797                                       );
00798
00800   NVSG_API virtual void postTraverseMap( const nvsg::MapArray * p
00801                                        , size_t index
00802                                        );
00803
00805
00808   NVSG_API virtual void preTraverseMap( const nvsg::MapMatrix * p
00809                                       , size_t col
00810                                       , size_t row
00811                                       );
00812
00814
00817   NVSG_API virtual void postTraverseMap( const nvsg::MapMatrix * p
00818                                        , size_t col
00819                                        , size_t row
00820                                        );
00821
00823
00826   NVSG_API virtual void preTraverseMapColumn( const nvsg::MapMatrix * p
00827                                             , size_t col
00828                                             );
00829
00831
00834   NVSG_API virtual void postTraverseMapColumn( const nvsg::MapMatrix * p
00835                                              , size_t col
00836                                              );
00837
00839
00841   template<typename T>
00842   T * beginEdit( const T * obj
00843                ) const
00844   {
00845     NVSG_TRACE();
00846     NVSG_ASSERT( ! m_readOnly );   // only non-readOnly traverser are allowed to edit
00847     return const_cast<T *>(obj);
00848   }
00849
00851
00853   template<typename T>
00854   const T * endEdit( const T * obj
00855                    ) const
00856   {
00857     NVSG_TRACE();
00858     return( obj );
00859   }
00860
00861 protected:
00862   std::stack<size_t>                  m_lodStack;
00863   std::stack<const nvsg::CullData *>  m_cullStack;
00864
00865   const nvsg::ViewState * m_viewState;
00866
00867   nvutil::ProblemLog m_problemLog;
00868
00869
00870   const nvsg::StateSet * m_nullStateSet;
00871
00872   // related to interrupting traversal from a different thread
00873   bool volatile m_interrupt;
00874   bool m_interrupted;
00875
00876 private:
00877   // geonode handling helper
00878   void traverse(const nvsg::GeoNode * p);
00879   // group handling helper
00880   template <typename GrpType>
00881   void traverseGroup(const GrpType * p);
00882   // general
00883   void traverse(const nvsg::Group * p);
00884   void traverse(const nvsg::Group * p, const nvsg::CullData * cd);
00885   // LOD specialization
00886   void traverse(const nvsg::LOD * p);
00887   void traverse(const nvsg::LOD * p, const nvsg::CullData * cd);
00888   // Switch specialization
00889   void traverse(const nvsg::Switch * p);
00890   void traverse(const nvsg::Switch * p, const nvsg::CullData * cd);
00891   // traverse a root node with a camera applied
00892   void traverse(const nvsg::Camera *p, const nvsg::Node *root);
00893
00894   // returns an object code to lookup the right handler for the given object.
00895   // returns OC_INVALID if no appropriate handler function could be found for the object.
00896   unsigned int getObjectTraversalCode(const nvsg::Object* object);
00897
00898 private:
00899   nvutil::MemFunTbl<Traverser> * m_mftbl; // member function table
00900                                   // accesible for derived classes via addObjectHandler API
00901   bool m_readOnly;
00902   bool (*m_pfnLock)( const nvutil::ISWMRSync  *obj );
00903   void (*m_pfnUnlock)( const nvutil::ISWMRSync  *obj );
00904 };
00905
00906 template<typename HandlerType>
00907 inline void Traverser::addObjectHandler(unsigned int objectCode, HandlerType handler)
00908 {
00909   m_mftbl->addEntry(objectCode, handler);
00910 }
00911
00912 inline unsigned int Traverser::getObjectTraversalCode(const nvsg::Object * object)
00913 {
00914   NVSG_TRACE();
00915
00916   unsigned int oc = object->getObjectCode();
00917   NVSG_ASSERT(oc!=nvsg::OC_INVALID);
00918
00919   if ( !m_mftbl->testEntry(oc) )
00920   {
00921     unsigned int orgOC = oc;
00922     do
00923     { // came across an unknown object
00924       // move up the object's hierarchy to find an appropriate handler
00925       oc = object->getHigherLevelObjectCode(oc);
00926       if ( nvsg::OC_INVALID==oc )
00927       { // proceed immediately without handling the object
00928         return oc;
00929       }
00930     }
00931     while ( !m_mftbl->testEntry(oc) );
00932
00933     // found an appropriate handler if we get here
00934
00935     // don't loop again for this object - register the handler
00936     addObjectHandler(orgOC, (*m_mftbl)[oc]);
00937   }
00938   return oc;
00939 }
00940
00941 inline void Traverser::traverseObject(const nvsg::Object* object)
00942 {
00943   NVSG_TRACE();
00944
00945   if ( m_interrupt )
00946   {
00947     // there was an interrupt request.
00948     // immediately quit traversal
00949     m_interrupted = true;
00950     return;
00951   }
00952
00953   // lock the object while being traversed
00954   (*m_pfnLock)( object );
00955
00956   unsigned int oc = nvsg::OC_INVALID;
00957   if ( nvsg::OC_INVALID != (oc=getObjectTraversalCode(object)) )
00958   {
00959 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
00960     void * __esp__0;
00961     void * __esp__1;
00962     __asm mov __esp__0, esp
00963 #endif
00964     (this->*(void (Traverser::*)(const nvsg::Object*))(*m_mftbl)[oc])(object);
00965 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
00966     __asm mov __esp__1, esp
00967     NVSG_ASSERT(__esp__1==__esp__0);
00968 #endif
00969   }
00970   (*m_pfnUnlock)(object);
00971 }
00972
00973 template <typename T>
00974 inline void Traverser::traverseObject( const nvsg::Object* object, T arg)
00975 {
00976   NVSG_TRACE();
00977
00978   if ( m_interrupt )
00979   {
00980     // there was an interrupt request.
00981     // immediately quit traversal
00982     m_interrupted = true;
00983     return;
00984   }
00985
00986   // lock the object while being traversed
00987   (*m_pfnLock)( object );
00988
00989   unsigned int oc = nvsg::OC_INVALID;
00990   if ( nvsg::OC_INVALID != (oc=getObjectTraversalCode(object)) )
00991   {
00992 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
00993     void * __esp__0;
00994     void * __esp__1;
00995     __asm mov __esp__0, esp
00996 #endif
00997     (this->*(void (Traverser::*)(const nvsg::Object*, T))(*m_mftbl)[oc])(object, arg);
00998 #if !defined(_WIN64) && defined(_WIN32) && !defined(NDEBUG)
00999     __asm mov __esp__1, esp
01000     NVSG_ASSERT(__esp__1==__esp__0);
01001 #endif
01002   }
01003
01004   (*m_pfnUnlock)( object );
01005 }
01006
01007 inline void Traverser::interruptTraversal()
01008 {
01009   NVSG_TRACE();
01010   m_interrupt = true;
01011 }
01012
01013 inline bool Traverser::wasTraversalInterrupted()
01014 {
01015   NVSG_TRACE();
01016   return m_interrupted;
01017 }
01018
01019 } // namespace
Generated on Fri Aug 4 08:33:10 2006 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 Fri Aug 4 08:36:13 2006 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:
00033       NVSG_API static const Triangles * create();
00034
00042       NVSG_API static const Triangles * createFromBase( const IndependentPrimitiveSet &rhs );
00043
00051       NVSG_API static const Triangles * createFromBase( const PrimitiveSet &rhs );
00052
00056       NVSG_API virtual const Triangles * clone() const;
00057
00062       NVSG_API bool hasFaces() const;
00063
00068       NVSG_API size_t getNumberOfFaces() const;
00069
00074       NVSG_API const Face3 * getFaces() const;
00075
00084       NVSG_API void setFaces( const Face3 * faces
00085                             , size_t numFaces );
00086
00102       NVSG_API void setFaces( size_t pos
00103                             , const Face3 * faces
00104                             , size_t numFaces );
00105
00111       NVSG_API Triangles & operator=(const Triangles & rhs);
00112
00113     protected:
00116       NVSG_API Triangles();
00117
00124       NVSG_API Triangles( const IndependentPrimitiveSet &rhs );
00125
00132       NVSG_API Triangles( const PrimitiveSet &rhs );
00133
00137       NVSG_API Triangles( const Triangles &rhs );
00138
00143       NVSG_API virtual ~Triangles();
00144   };
00145
00155   NVSG_API void calculateTangentSpace( const Triangles * t
00156                                      , size_t tu = 0
00157                                      , size_t tg = 1
00158                                      , size_t bn = 2 );
00159
00164   NVSG_API void generateNormals( const Triangles * q );
00165
00166   // - - - - - - - - - - - - - - - - - - - - - - - - -
00167   // inlines
00168   // - - - - - - - - - - - - - - - - - - - - - - - - -
00169
00170   inline bool Triangles::hasFaces()  const
00171   {
00172     NVSG_TRACE();
00173     return( 3 <= getNumberOfIndices() );
00174   }
00175
00176   inline size_t Triangles::getNumberOfFaces()  const
00177   {
00178     NVSG_TRACE();
00179     return( getNumberOfIndices() / 3 );
00180   }
00181
00182   inline const Face3 * Triangles::getFaces() const
00183   {
00184     NVSG_TRACE();
00185     return( (const Face3 *) getIndices() );
00186   }
00187
00188   inline void Triangles::setFaces( const Face3* pFaces, size_t numFaces )
00189   {
00190     NVSG_TRACE();
00191     setIndices( (const unsigned int *) pFaces, 3 * numFaces );
00192   }
00193
00194   inline void Triangles::setFaces( size_t pos, const Face3* pFaces, size_t numFaces )
00195   {
00196     NVSG_TRACE();
00197     if ( (size_t)-1 != pos )
00198     {
00199       pos *= 3;
00200     }
00201     setIndices( pos, (const unsigned int *) pFaces, 3 * numFaces );
00202   }
00203 }
Generated on Fri Aug 4 08:33:10 2006 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 Fri Aug 4 08:36:14 2006 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
00017 #include  "nvtraverser/Traverser.h"
00018
00019 namespace nvtraverser
00020 {
00021
00023
00024 class TriangulateTraverser : public Traverser
00025 {
00026   public:
00028     NVSG_API TriangulateTraverser(void);
00029
00030   protected:
00032     NVSG_API virtual ~TriangulateTraverser(void);
00033
00035
00036     NVSG_API virtual void  handleAnimatedQuads(
00037       const nvsg::AnimatedQuads *p
00038     );
00039
00041
00042     NVSG_API virtual void  handleGeoNode(
00043       const nvsg::GeoNode *p
00044     );
00045
00047
00048     NVSG_API virtual void  handleQuads(
00049       const nvsg::Quads *p
00050     );
00051
00053
00054     NVSG_API virtual void  handleQuadStrips(
00055       const nvsg::QuadStrips *p
00056     );
00057
00058   private:
00059     std::vector<std::pair<const nvsg::PrimitiveSet*,const nvsg::PrimitiveSet*> >  m_primitiveSetReplaces;
00060 };
00061
00062 }
Generated on Fri Aug 4 08:33:10 2006 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 Fri Aug 4 08:36:15 2006 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:
00033       NVSG_API static const TriFans * create( void );
00034
00042       NVSG_API static const TriFans * createFromBase( const StrippedPrimitiveSet &rhs );
00043
00047       NVSG_API virtual const TriFans * clone() const;
00048
00053       NVSG_API TriFans & operator=(const TriFans & rhs);
00054
00055     protected:
00058       NVSG_API TriFans(void);
00059
00065       NVSG_API TriFans( const StrippedPrimitiveSet &rhs );
00066
00070       NVSG_API TriFans( const TriFans &rhs );
00071
00076       NVSG_API virtual ~TriFans(void);
00077   };
00078
00088   NVSG_API void calculateTangentSpace( const TriFans * tf
00089                                      , size_t tu = 0
00090                                      , size_t tg = 1
00091                                      , size_t bn = 2 );
00092
00097   NVSG_API void generateNormals( const TriFans * q );
00098
00099 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


TriStrips.h File Reference

#include "nvsgcommon.h"
#include "nvsg/nvsg.h"
#include "nvsg/StrippedPrimitiveSet.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 Fri Aug 4 08:36:16 2006 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/nvsg.h"
00017 #include "nvsg/StrippedPrimitiveSet.h"
00018
00019 namespace nvsg
00020 {
00037   class TriStrips : public StrippedPrimitiveSet
00038   {
00039     public:
00043       NVSG_API static const TriStrips * create( void );
00044
00052       NVSG_API static const TriStrips * createFromBase( const StrippedPrimitiveSet &rhs );
00053
00057       NVSG_API virtual const TriStrips * clone() const;
00058
00063       NVSG_API TriStrips & operator=(const TriStrips & rhs);
00064
00065     protected:
00068       NVSG_API TriStrips(void);
00069
00075       NVSG_API TriStrips( const StrippedPrimitiveSet &rhs );
00076
00080       NVSG_API TriStrips( const TriStrips &rhs );
00081
00086       NVSG_API virtual ~TriStrips(void);
00087   };
00088
00098   NVSG_API void calculateTangentSpace( const TriStrips * ts
00099                                      , size_t tu = 0
00100                                      , size_t tg = 1
00101                                      , size_t bn = 2 );
00102
00107   NVSG_API void generateNormals( const TriStrips * q );
00108
00109 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


Vec2f.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vecnf.h"

Include dependency graph for Vec2f.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

Defines

#define | NVSG_TRACE_VEC2F(v) NVSG_TRACE_OUT_F((#v " 2-component-vector output:\n\t%f\t%f\n", v[0], v[1]))

Detailed Description

Generated on Fri Aug 4 08:36:18 2006 for NVSGSDK by NVIDIA


Vec2f.h Source File

Vec2f.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/Vecnf.h"
00017
00018 #if !defined(NDEBUG)
00019 # define NVSG_TRACE_VEC2F(v) \
00020   NVSG_TRACE_OUT_F((#v " 2-component-vector output:\n\t%f\t%f\n", v[0], v[1]))
00021 #else
00022 # define NVSG_TRACE_VEC2F(v)
00023 #endif
00024
00025 namespace nvmath
00026 {
00028   class Vec2f : public Vecnf<2>
00029   {
00030     public:
00032
00033       NVSG_API Vec2f( void );
00034
00036
00037       NVSG_API Vec2f( float x
00038                     , float y
00039                     );
00040
00042       NVSG_API Vec2f( const Vecnf<2> & v );
00043
00045       NVSG_API void set( float x
00046                        , float y
00047                        );
00048   };
00049
00050   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00051   // non-member functions
00052   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00056   inline const Vec2f operator*( float f
00057                               , const Vec2f &v
00058                               )
00059   {
00060     return( v * f );
00061   }
00062
00063   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00064   // inlines
00065   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00066   inline Vec2f::Vec2f( void )
00067   {
00068   }
00069
00070   inline Vec2f::Vec2f( float x, float y )
00071   {
00072     (*this)[0] = x;
00073     (*this)[1] = y;
00074   }
00075
00076   inline Vec2f::Vec2f( const Vecnf<2> &v )
00077     : Vecnf<2>( v )
00078   {
00079   }
00080
00081   inline void Vec2f::set( float x, float y )
00082   {
00083     (*this)[0]=x;
00084     (*this)[1]=y;
00085   }
00086
00087 } // end namespace nvmath
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


Vec3f.h File Reference

#include "nvsgcommon.h"
#include <algorithm>
#include <vector>
#include "nvmath/nvmath.h"
#include "nvmath/Vecnf.h"

Include dependency graph for Vec3f.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

Defines

#define | NVSG_TRACE_VEC3F(v) NVSG_TRACE_OUT_F((#v " 3-component-vector output:\n\t%f\t%f\t%f\n", v[0], v[1], v[2]))

Detailed Description

Generated on Fri Aug 4 08:36:19 2006 for NVSGSDK by NVIDIA


Vec3f.h Source File

Vec3f.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 <algorithm>
00018 #include <algorithm>
00019 #include <vector>
00020 #include "nvmath/nvmath.h"
00021 #include "nvmath/Vecnf.h"
00022
00023 #if !defined(NDEBUG)
00024 # define NVSG_TRACE_VEC3F(v) \
00025   NVSG_TRACE_OUT_F((#v " 3-component-vector output:\n\t%f\t%f\t%f\n", v[0], v[1], v[2]))
00026 #else
00027 # define NVSG_TRACE_VEC3F(v)
00028 #endif
00029
00030 namespace nvmath
00031 {
00032   class Sphere3f;
00033   class Vec4f;
00034
00036   class Vec3f : public Vecnf<3>
00037   {
00038     public:
00040
00041       NVSG_API Vec3f( void );
00042
00044
00045       NVSG_API Vec3f( float x
00046                     , float y
00047                     , float z
00048                     );
00049
00051       NVSG_API Vec3f( const Vecnf<3> &v
00052                     );
00053
00055
00056       NVSG_API Vec3f( const Vecnf<4> &v
00057                     );
00058
00060
00062       NVSG_API Vec3f& operator=( const Vec4f &v
00063                                );
00064
00066
00067       NVSG_API const Vec3f operator-(void) const;
00068       // don't hide base class' operator-
00069       using Vecnf<3>::operator-;
00070
00072       NVSG_API void set( float x
00073                        , float y
00074                        , float z
00075                        );
00076   };
00077
00078   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00079   // non-member functions
00080   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00084   inline Vec3f normalize( const Vec3f& v
00085                         )
00086   {
00087     float norm = std::max( length(v), FLT_EPSILON );
00088     // return value optimization: safe construction/destruction of a temporary object
00089     return( Vec3f( v[0]/norm, v[1]/norm, v[2]/norm ) );
00090   }
00091
00094   inline  void  normalize( const std::vector<Vec3f> &vecIn
00095                          , std::vector<Vec3f> &vecOut
00096                          )
00097   {
00098     std::vector<Vec3f> tmp;
00099     std::transform( vecIn.begin(), vecIn.end()
00100                   , std::inserter(tmp, tmp.begin()), (Vec3f (*)(const Vec3f&))&normalize );
00101     tmp.swap( vecOut );
00102   }
00103
00107   inline const Vec3f operator*( float f
00108                               , const Vec3f &v
00109                               )
00110   {
00111     return( v * f );
00112   }
00113
00118   inline const Vec3f  operator^( const Vecnf<3> &v0, const Vecnf<3> &v1 )
00119   {
00120     return( Vec3f( v0[1] * v1[2] - v0[2] * v1[1],
00121                    v0[2] * v1[0] - v0[0] * v1[2],
00122                    v0[0] * v1[1] - v0[1] * v1[0]
00123                 )
00124           );
00125   }
00126
00131   inline bool areCollinear( const Vec3f &v0
00132                           , const Vec3f &v1
00133                           , float epsilon = FLT_EPSILON
00134                           )
00135   {
00136     return( length( v0 ^ v1 ) < epsilon );
00137   }
00138
00146   NVSG_API void  smoothNormals( const std::vector<Vec3f> &vertices
00147                               , const Sphere3f &sphere
00148                               , float creaseAngle
00149                               , std::vector<Vec3f> &normals
00150                               );
00151
00152   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00153   // inlines
00154   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00155   inline void Vec3f::set( float x, float y, float z )
00156   {
00157     (*this)[0]=x;
00158     (*this)[1]=y;
00159     (*this)[2]=z;
00160   }
00161
00162   inline const Vec3f Vec3f::operator-(void) const
00163   {
00164     return (Vec3f(-(*this)[0], -(*this)[1], -(*this)[2]));
00165   }
00166
00167 } // end namespace nvmath
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


Vec4f.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vec3f.h"
#include "nvmath/Vecnf.h"

Include dependency graph for Vec4f.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

Defines

#define | NVSG_TRACE_VEC4F(v) NVSG_TRACE_OUT_F((#v " 4-component-vector output:\n\t%f\t%f\t%f\t%f\n", v[0], v[1], v[2], v[3]))

Detailed Description

Generated on Fri Aug 4 08:36:21 2006 for NVSGSDK by NVIDIA


Vec4f.h Source File

Vec4f.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 "nvmath/Vec3f.h"
00018 #include "nvmath/Vecnf.h"
00019
00020 #if !defined(NDEBUG)
00021 # define NVSG_TRACE_VEC4F(v) \
00022   NVSG_TRACE_OUT_F((#v " 4-component-vector output:\n\t%f\t%f\t%f\t%f\n", v[0], v[1], v[2], v[3]))
00023 #else
00024 # define NVSG_TRACE_VEC4F(v)
00025 #endif
00026
00027 namespace nvmath
00028 {
00030   class Vec4f : public Vecnf<4>
00031   {
00032     public:
00034
00035       NVSG_API Vec4f( void );
00036
00038
00039       NVSG_API Vec4f( float x
00040                     , float y
00041                     , float z
00042                     , float w
00043                     );
00044
00046       NVSG_API Vec4f( const Vec3f &v3
00047                     , float w
00048                     );
00049
00051       NVSG_API Vec4f( const Vecnf<4> &v
00052                     );
00053
00055       NVSG_API void set( float x
00056                        , float y
00057                        , float z
00058                        , float w
00059                        );
00060   };
00061
00062   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00063   // non-member functions
00064   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00068   inline const Vec4f operator*( float f
00069                               , const Vec4f &v
00070                               )
00071   {
00072     return( v * f );
00073   }
00074
00075   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00076   // inlines
00077   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00078   inline Vec4f::Vec4f( void )
00079   {
00080   }
00081
00082   inline Vec4f::Vec4f( float x, float y, float z, float w )
00083   {
00084     (*this)[0]=x;
00085     (*this)[1]=y;
00086     (*this)[2]=z;
00087     (*this)[3]=w;
00088   }
00089
00090   inline Vec4f::Vec4f( const Vec3f &v3, float w )
00091   {
00092     (*this)[0] = v3[0];
00093     (*this)[1] = v3[1];
00094     (*this)[2] = v3[2];
00095     (*this)[3] = w;
00096   }
00097
00098   inline Vec4f::Vec4f( const Vecnf<4> &v )
00099     : Vecnf<4>( v )
00100   {
00101   }
00102
00103   inline void Vec4f::set( float x, float y, float z, float w )
00104   {
00105     (*this)[0]=x;
00106     (*this)[1]=y;
00107     (*this)[2]=z;
00108     (*this)[3]=w;
00109   }
00110
00111 } // end namespace nvmath
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


Vecnf.h File Reference

#include "nvsgcommon.h"
#include "nvutil/Assert.h"
#include <float.h>
#include <math.h>
#include "nvmath/nvmath.h"

Include dependency graph for Vecnf.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 Fri Aug 4 08:36:22 2006 for NVSGSDK by NVIDIA


Vecnf.h Source File

Vecnf.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/Assert.h"
00018 #include  <float.h>
00019 #include  <math.h>
00020
00021 #include "nvmath/nvmath.h"
00022
00023 namespace nvmath
00024 {
00026   template<unsigned char n> class Vecnf
00027   {
00028     public:
00030
00031       Vecnf<n>( void );
00032
00034       Vecnf<n>( const Vecnf<n> & v
00035               );
00036
00038
00039       float& operator[]( size_t i
00040                        );
00041
00043
00044       const float& operator[]( size_t i
00045                              ) const;
00046
00048
00049       const Vecnf<n> operator-( void ) const;
00050
00052
00053       const Vecnf<n> operator*( float  f
00054                               ) const;
00055
00057
00058       const Vecnf<n> operator*( double f
00059                               ) const;
00060
00062
00063       const float operator*( const Vecnf<n> &v
00064                            ) const;
00065
00067
00068       const Vecnf<n> operator/( float f
00069                               ) const;
00070
00072
00073       const Vecnf<n> operator/( double f
00074                               ) const;
00075
00077
00078       const Vecnf<n> operator+( const Vecnf<n> &v
00079                               ) const;
00080
00082
00083       const Vecnf<n> operator-( const Vecnf<n> &v
00084                               ) const;
00085
00087
00089       bool operator==( const Vecnf<n> &v
00090                      ) const;
00091
00093
00095       bool operator!=( const Vecnf<n> &v
00096                      ) const;
00097
00099
00100       Vecnf<n> & operator=( const Vecnf<n> &v
00101                           );
00102
00104
00105       Vecnf<n> & operator*=( float f
00106                            );
00107
00109
00110       Vecnf<n> & operator*=( double f
00111                            );
00112
00114
00115       Vecnf<n> & operator/=( float f
00116                            );
00117
00119
00120       Vecnf<n> & operator/=( double f
00121                            );
00122
00124
00125       Vecnf<n> & operator+=( const Vecnf<n> &v
00126                            );
00127
00129
00130       Vecnf<n> & operator-=( const Vecnf<n> &v
00131                            );
00132
00134
00135       const float* getPtr( void ) const;
00136
00138
00139       float normalize( void );
00140
00142
00143       void orthogonalize( const Vecnf<n> &v
00144                         );
00145
00147
00148       void orthonormalize( const Vecnf<n>& v
00149                          );
00150
00151     private:
00152       float m_vec[n];
00153   };
00154
00155   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00156   // non-member functions
00157   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00163    template<unsigned char n> bool areOpposite( const Vecnf<n> &v0
00164                                              , const Vecnf<n> &v1
00165                                              , float epsilon = FLT_EPSILON
00166                                              )
00167    {
00168      NVSG_ASSERT( isNormalized( v0, FLT_EPSILON ) );
00169      NVSG_ASSERT( isNormalized( v1, FLT_EPSILON ) );
00170      return( ( 1.0f + v0 * v1 ) <= epsilon );
00171    }
00172
00178   template<unsigned char n> bool areOrthogonal( const Vecnf<n> &v0
00179                                               , const Vecnf<n> &v1
00180                                               , float epsilon = FLT_EPSILON
00181                                               )
00182   {
00183     return( fabs( v0 * v1 ) <= epsilon );
00184   }
00185
00190   template<unsigned char n> bool areOrthonormal( const Vecnf<n> &v0
00191                                                , const Vecnf<n> &v1
00192                                                , float epsilon = FLT_EPSILON
00193                                                )
00194   {
00195     return(   isNormalized( v0, epsilon )
00196           &&  isNormalized( v1, epsilon )
00197           &&  areOrthogonal( v0, v1, 16*epsilon ) );
00198   }
00199
00205   template<unsigned char n> bool areSimilar( const Vecnf<n> &v0
00206                                            , const Vecnf<n> &v1
00207                                            , float epsilon = FLT_EPSILON
00208                                            )
00209   {
00210     NVSG_ASSERT( 0.0f <= epsilon );
00211     bool similar = true;
00212     for ( size_t i=0 ; similar && i<n ; i++ )
00213     {
00214       similar = ( fabs( v0[i] - v1[i] ) <= epsilon );
00215     }
00216     return( similar );
00217   }
00218
00223   template<unsigned char n> float distance( const Vecnf<n> &p0
00224                                           , const Vecnf<n> &p1
00225                                           )
00226   {
00227     return( length( p0 - p1 ) );
00228   }
00229
00234   template<unsigned char n> bool isNormalized( const Vecnf<n> &v
00235                                              , float epsilon = FLT_EPSILON
00236                                              )
00237   {
00238     return( fabs( length( v ) - 1.0f ) <= epsilon );
00239   }
00240
00245   template<unsigned char n> bool isNull( const Vecnf<n> &v
00246                                        , float epsilon = FLT_EPSILON
00247                                        )
00248   {
00249     return( length( v ) <= epsilon );
00250   }
00251
00256   template<unsigned char n> float length( const Vecnf<n> &v
00257                                         )
00258   {
00259     return( sqrtf( lengthSquared( v ) ) );
00260   }
00261
00266   template<unsigned char n> double lengthd( const Vecnf<n> &v
00267                                           )
00268   {
00269     double l = square( v[0] );
00270     for ( size_t i=1 ; i<n ; i++ )
00271     {
00272       l += square( v[i] );
00273     }
00274     return( sqrt( l ) );
00275   }
00276
00280   template<unsigned char n> float lengthSquared( const Vecnf<n> &v
00281                                                )
00282   {
00283     return( v * v );
00284   }
00285
00289   template<unsigned char n> float maxElement( const Vecnf<n> &v
00290                                             )
00291   {
00292     float f = fabsf( v[0] );
00293     for ( size_t i=1 ; i<n ; i++ )
00294     {
00295       float t = fabsf( v[i] );
00296       if ( f < t )
00297       {
00298         f = t;
00299       }
00300     }
00301     return( f );
00302   }
00303
00307   template<unsigned char n> float minElement( const Vecnf<n> &v
00308                                             )
00309   {
00310     float f = fabsf( v[0] );
00311     for ( size_t i=1 ; i<n ; i++ )
00312     {
00313       float t = fabsf( v[i] );
00314       if ( t < f )
00315       {
00316         f = t;
00317       }
00318     }
00319     return( f );
00320   }
00321
00325   template<unsigned char n> Vecnf<n>  operator*( float f
00326                                                , const Vecnf<n> &v
00327                                                )
00328   {
00329     return( v * f );
00330   }
00331
00335   template<unsigned char n> Vecnf<n>  operator*( double f
00336                                                , const Vecnf<n> &v
00337                                                )
00338   {
00339     return( v * f );
00340   }
00341
00342   template<unsigned char n> Vecnf<n> orthonormalize( const Vecnf<n> &v0
00343                                                    , const Vecnf<n> &v1 )
00344   {
00345     NVSG_ASSERT( isNormalized( v0 ) && isNormalized( v1 ) && ! areCollinear( v0, v1 ) );
00346     //  determine the orthogonal projection of v1 on v0: ( v0 * v1 ) * v0
00347     //  and subtract it from v1 resulting in the orthogonalized version of v1
00348     return( normalize( v1 - ( v0 * v1 ) * v0 ) );
00349   }
00350
00351   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00352   // "inlines"
00353   // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00354   template<unsigned char n> Vecnf<n>::Vecnf( void )
00355   {
00356   }
00357
00358   template<unsigned char n> Vecnf<n>::Vecnf( const Vecnf<n> &v )
00359   {
00360     for ( size_t i=0 ; i<n ; i++ )
00361     {
00362       m_vec[i] = v[i];
00363     }
00364   }
00365
00366   template<unsigned char n> float& Vecnf<n>::operator[]( size_t i )
00367   {
00368     NVSG_ASSERT( 0 <= i && i < n );
00369     return( m_vec[i] );
00370   }
00371
00372   template<unsigned char n> const float& Vecnf<n>::operator[]( size_t i ) const
00373   {
00374     NVSG_ASSERT( 0 <= i && i < n );
00375     return( m_vec[i] );
00376   }
00377
00378   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator-( void ) const
00379   {
00380     Vecnf<n> v;
00381     for ( size_t i=0 ; i<n ; i++ )
00382     {
00383       v[i] = -m_vec[i];
00384     }
00385     return( v );
00386   }
00387
00388   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator*( float f ) const
00389   {
00390     Vecnf<n> ret( *this );
00391     return( ret *= f );
00392   }
00393
00394   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator*( double f ) const
00395   {
00396     Vecnf<n> ret( *this );
00397     return( ret *= f );
00398   }
00399
00400   template<unsigned char n> const float Vecnf<n>::operator*( const Vecnf<n> &v ) const
00401   {
00402     double f(0);
00403     for ( size_t i=0 ; i<n ; i++ )
00404     {
00405       f += m_vec[i] * v[i];
00406     }
00407     return( (float)f );
00408   }
00409
00410   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator/( float f ) const
00411   {
00412     NVSG_ASSERT( FLT_EPSILON < fabs( f ) );
00413     Vecnf<n> ret( *this );
00414     return( ret /= f );
00415   }
00416
00417   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator/( double f ) const
00418   {
00419     NVSG_ASSERT( FLT_EPSILON < fabs( f ) );
00420     Vecnf<n> ret( *this );
00421     return( ret /= f );
00422   }
00423
00424   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator+( const Vecnf<n> &v ) const
00425   {
00426     Vecnf<n> ret( *this );
00427     return( ret += v );
00428   }
00429
00430   template<unsigned char n> const Vecnf<n> Vecnf<n>::operator-( const Vecnf<n> &v ) const
00431   {
00432     Vecnf<n> ret( *this );
00433     return( ret -= v );
00434   }
00435
00436   template<unsigned char n> bool Vecnf<n>::operator==( const Vecnf<n> &v ) const
00437   {
00438     bool equal = true;
00439     for ( unsigned char i=0 ; equal && i<n ; i++ )
00440     {
00441       equal = ( fabs( m_vec[i] - v[i] ) < FLT_EPSILON );
00442     }
00443     return( equal );
00444   }
00445
00446   template<unsigned char n> bool Vecnf<n>::operator!=( const Vecnf<n> &v ) const
00447   {
00448     return( ! ( *this == v ) );
00449   }
00450
00451   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator=( const Vecnf<n> &v )
00452   {
00453     for ( size_t i=0 ; i<n ; i++ )
00454     {
00455       m_vec[i] = v[i];
00456     }
00457     return( *this );
00458   }
00459
00460   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator*=( float f )
00461   {
00462     for ( size_t i=0 ; i<n ; i++ )
00463     {
00464       m_vec[i] *= f;
00465     }
00466     return( *this );
00467   }
00468
00469   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator*=( double f )
00470   {
00471     for ( size_t i=0 ; i<n ; i++ )
00472     {
00473       m_vec[i] *= f;
00474     }
00475     return( *this );
00476   }
00477
00478   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator/=( float f )
00479   {
00480     NVSG_ASSERT( FLT_EPSILON < fabs( f ) );
00481     float invF = 1.0f / f;
00482     for ( size_t i=0 ; i<n ; i++ )
00483     {
00484       m_vec[i] *= invF;
00485     }
00486     return( *this );
00487   }
00488
00489   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator/=( double f )
00490   {
00491     NVSG_ASSERT( FLT_EPSILON < fabs( f ) );
00492     double invF = 1.0 / f;
00493     for ( size_t i=0 ; i<n ; i++ )
00494     {
00495       m_vec[i] = (float)(m_vec[i] * invF);
00496     }
00497     return( *this );
00498   }
00499
00500   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator+=( const Vecnf<n> &v )
00501   {
00502     for ( size_t i=0 ; i<n ; i++ )
00503     {
00504       m_vec[i] += v[i];
00505     }
00506     return( *this );
00507   }
00508
00509   template<unsigned char n> Vecnf<n> & Vecnf<n>::operator-=( const Vecnf<n> &v )
00510   {
00511     for ( size_t i=0 ; i<n ; i++ )
00512     {
00513       m_vec[i] -= v[i];
00514     }
00515     return( *this );
00516   }
00517
00518   template<unsigned char n> const float* Vecnf<n>::getPtr( void ) const
00519   {
00520     return( &m_vec[0] );
00521   }
00522
00523   template<unsigned char n> float Vecnf<n>::normalize( void )
00524   {
00525     double norm = lengthd( *this );
00526     if ( FLT_EPSILON < norm )
00527     {
00528       *this /= norm;
00529       NVSG_ASSERT( isNormalized( *this, FLT_EPSILON ) );
00530     }
00531     return( (float)norm );
00532   }
00533
00534   template<unsigned char n> void Vecnf<n>::orthonormalize( const Vecnf<n> &v )
00535   {
00536     NVSG_ASSERT( isNormalized( *this ) );
00537     NVSG_ASSERT( isNormalized( v ) );
00538     //  determine the orthogonal projection of this on v : ( v * this ) * v
00539     //  and subtract it from this resulting in the orthogonalized this
00540     *this = *this - ( v * *this ) * v;
00541     normalize();    //  and normalize it
00542   }
00543
00544 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


VertexAttributeSet.h File Reference

#include "nvsgcommon.h"
#include "nvmath/Vec3f.h"
#include "nvsg/Object.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 Fri Aug 4 08:36:23 2006 for NVSGSDK by NVIDIA


VertexAttributeSet.h Source File

VertexAttributeSet.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/Vec3f.h"
00017 #include "nvsg/Object.h"
00018 #include "nvutil/BitMask.h"
00019
00020
00021 namespace nvsg
00022 {
00023   //  forward declarations
00024   class PrimitiveSet;
00025   class VertexAttributeSet;
00026
00027   // VertexAttribute serves as a private helper class providing data management (so no need for docs)
00028 # if ! defined( DOXYGEN_IGNORE )
00029   class VertexAttribute
00030   {
00031     public:
00032       // default constructs a VertexAttribute object
00033       VertexAttribute();
00034       // cleanup on destruction
00035       ~VertexAttribute();
00036
00037       // Copies float data pointed to by fdata to the vertex attribute's internal data storage.
00038       // fdim specifies the dimension, in terms of float, of a single data element.
00039       // count specifies the number of data elements to be copied, so that always
00040       // count * fdim floats are copied to the internal data storage.
00041       // Behavior is undefined if fdata is an invalid pointer.
00042       void setData(unsigned int fdim, const float * fdata, size_t count);
00043
00044       // Overrides the data element at position pos with the data element pointed to by fdata.
00045       // Behavior is undefined if either the specified position is invalid, or if fdata is an invalid pointer.
00046       // Behavior also is undefined if fdim doesn't match the dimension of the data element currently stored
00047       // at the specified position.
00048       void setData(unsigned int fdim, size_t pos, const float * fdata, size_t count);
00049
00050       // Clear the data
00051       void clearData( void );
00052
00053       // Returns a pointer to the float data stored in this vertex attrib,
00054       // or a NULL pointer if no data is currently strored
00055       const float * getData() const;
00056
00057       // Returns the dimension, in terms of float, of the stored data.
00058       // If no data is stored in this vertex attrib, the return value might be random.
00059       unsigned int getDataDimension() const;
00060
00061       // Returns the number of data elements currently stored in this vertex attribute
00062       size_t getNumberOfData() const;
00063
00064     private:
00065       unsigned int        m_fdim;   // dimension of data elements in terms of float
00066       std::vector<float>  m_fdata;  // float data storage (contiguous memory)
00067       size_t              m_count;  // number of data elements (==m_fdata.size()/m_fdim)
00068                                     // serves as a cache to improve performance when querying the current data count
00069   };
00070
00071   inline void VertexAttribute::clearData( void )
00072   {
00073     m_fdim = 0;
00074     m_count = 0;
00075     m_fdata.clear();
00076   }
00077
00078   inline const float * VertexAttribute::getData() const
00079   {
00080     NVSG_TRACE();
00081     return !m_fdata.empty() ? &m_fdata[0] : NULL;
00082   }
00083
00084   inline unsigned int VertexAttribute::getDataDimension() const
00085   {
00086     NVSG_TRACE();
00087     NVSG_ASSERT(m_fdata.empty() || !(m_fdata.size()%m_fdim)); // this would be a serious error!
00088     NVSG_ASSERT(m_fdata.empty() == !m_fdim);
00089     return m_fdim;
00090   }
00091
00092   inline size_t VertexAttribute::getNumberOfData() const
00093   {
00094     NVSG_TRACE();
00095     NVSG_ASSERT(m_fdata.empty() == !m_fdim);
00096     NVSG_ASSERT(m_fdata.empty() || !(m_fdata.size()%m_fdim)); // this would be a serious error
00097     NVSG_ASSERT(m_fdata.empty() || m_count==m_fdata.size()/m_fdim); // count cache is not up to data
00098     // --> serious, as well
00099     return m_count;
00100   }
00101 #endif    //  DOXYGEN_IGNORE
00102
00104
00106   class VertexAttributeSet : public Object
00107   {
00108     public:
00110
00111       enum
00112       {
00113         VERTEX_POSITION  = 0,
00114         VERTEX_WEIGHTS,
00115         NORMAL,
00116         PRIMARY_COLOR,
00117         SECONDARY_COLOR,
00118         FOG_COORDINATE,
00119         UNUSED_1,
00120         UNUSED_2,
00121         TEXTURE_COORD_0,
00122         TEXTURE_COORD_1,
00123         TEXTURE_COORD_2,
00124         TEXTURE_COORD_3,
00125         TEXTURE_COORD_4,
00126         TEXTURE_COORD_5,
00127         TEXTURE_COORD_6,
00128         TEXTURE_COORD_7,
00129         NUMBER_OF_VERTEX_ATTRIBUTES
00130       };
00131
00133       enum
00134       {
00135           V3F   = BIT0
00136         , VW1F  = BIT1
00137         , N3F   = BIT2
00138         , VC3F  = BIT3
00139         , VC4F  = BIT4
00140         , SVC3F = BIT5
00141         , SVC4F = BIT6
00142         , F1F   = BIT7
00143         , T01F  = BIT8
00144         , T02F  = BIT9
00145         , T03F  = BIT10
00146         , T11F  = BIT11
00147         , T12F  = BIT12
00148         , T13F  = BIT13
00149         , T21F  = BIT14
00150         , T22F  = BIT15
00151         , T23F  = BIT16
00152         , T31F  = BIT17
00153         , T32F  = BIT18
00154         , T33F  = BIT19
00155         , T41F  = BIT20
00156         , T42F  = BIT21
00157         , T43F  = BIT22
00158         , T51F  = BIT23
00159         , T52F  = BIT24
00160         , T53F  = BIT25
00161         , T61F  = BIT26
00162         , T62F  = BIT27
00163         , T63F  = BIT28
00164         , T71F  = BIT29
00165         , T72F  = BIT30
00166         , T73F  = BIT31
00167         , V3F_N3F               = V3F | N3F
00168         , V3F_N3F_VC3F          = V3F | N3F | VC3F
00169         , V3F_N3F_VC4F          = V3F | N3F | VC4F
00170         , V3F_N3F_VC3F_T2F      = V3F | N3F | VC3F | T02F
00171         , V3F_N3F_VC4F_T2F      = V3F | N3F | VC4F | T02F
00172         , V3F_N3F_T2F           = V3F | N3F | T02F
00173         , V3F_N3F_T2F_TG3F_BN3F = V3F | N3F | T02F | T13F | T23F
00174       };
00175
00177
00178       NVSG_API static const VertexAttributeSet * create( void );
00179
00181
00182       NVSG_API virtual const VertexAttributeSet * clone( void ) const;
00183
00185
00186       NVSG_API virtual bool isDataShared( void ) const;
00187
00189
00190       NVSG_API virtual DataID getDataID( void ) const;
00191
00193
00194       NVSG_API unsigned int getInterleavedFormat() const;
00195
00197
00217       NVSG_API size_t getNumberOfVertexAttributeBytes( size_t attrib
00218                                                      ) const;
00219
00221
00242       NVSG_API const float * getVertexAttributeData( size_t attrib
00243                                                    ) const;
00244
00246
00270       NVSG_API unsigned int getVertexAttributeDataDim( size_t attrib
00271                                                      ) const;
00272
00274
00294       NVSG_API size_t getNumberOfVertexAttributeData( size_t attrib
00295                                                     ) const;
00296
00298
00323       NVSG_API void setVertexAttributeData( size_t          attrib
00324                                           , unsigned int    fdim
00325                                           , const float   * fdata
00326                                           , size_t          count
00327                                           );
00328
00330
00365       NVSG_API void setVertexAttributeData( size_t          attrib
00366                                           , unsigned int    fdim
00367                                           , size_t          pos
00368                                           , const float   * fdata
00369                                           , size_t          count
00370                                           );
00371
00373       NVSG_API void clearVertexAttributeData( size_t attrib
00374                                             );
00375
00377
00379       NVSG_API size_t getNumberOfVertices( void ) const;
00380
00382
00386       NVSG_API const nvmath::Vec3f * getVertices( void ) const;
00387
00389
00393       NVSG_API void setVertices( const nvmath::Vec3f  * verts
00394                                , size_t                 count
00395                                );
00396
00398
00412       NVSG_API void setVertices( size_t                 pos
00413                                , const nvmath::Vec3f  * verts
00414                                , size_t                 count
00415                                );
00416
00418
00420       NVSG_API size_t getNumberOfNormals( void ) const;
00421
00423
00427       NVSG_API const nvmath::Vec3f * getNormals( void ) const;
00428
00430
00434       NVSG_API void setNormals( const nvmath::Vec3f * nor
00435                               , size_t                count
00436                               );
00437
00439
00450       NVSG_API void setNormals( size_t                pos
00451                               , const nvmath::Vec3f * nor
00452                               , size_t                count
00453                               );
00454
00456
00457       NVSG_API bool hasTexCoords( void ) const;
00458
00460
00464       NVSG_API size_t getNumberOfTexCoords( size_t texUnit
00465                                           ) const;
00466
00468
00473       NVSG_API const float * getTexCoords( size_t texUnit
00474                                          ) const;
00475
00477
00482       NVSG_API unsigned int getTexCoordsDim( size_t texUnit
00483                                            ) const;
00484
00486       NVSG_API void clearTexCoords( size_t          texUnit
00487                                 );
00488
00490
00496       NVSG_API void setTexCoords( size_t          texUnit
00497                                 , unsigned int    fdim
00498                                 , const float   * coords
00499                                 , size_t          count
00500                                 );
00501
00503
00517       NVSG_API void setTexCoords( size_t          texUnit
00518                                 , unsigned int    fdim
00519                                 , size_t          pos
00520                                 , const float   * coords
00521                                 , size_t          count
00522                                 );
00523
00525
00526       NVSG_API size_t getNumberOfColors( void ) const;
00527
00529
00533       NVSG_API const float * getColors( void ) const;
00534
00536
00540       NVSG_API unsigned int getColorsDim( void ) const;
00541
00543
00548       NVSG_API void setColors( unsigned int   fdim
00549                              , const float  * cols
00550                              , size_t         count
00551                              );
00552
00554
00567       NVSG_API void setColors( unsigned int   fdim
00568                              , size_t         pos
00569                              , const float  * cols
00570                              , size_t         count
00571                              );
00572
00574
00575       NVSG_API size_t getNumberOfSecondaryColors( void ) const;
00576
00578
00579       NVSG_API const float * getSecondaryColors( void ) const;
00580
00582
00584       NVSG_API unsigned int getSecondaryColorsDim( void ) const;
00585
00587
00592       NVSG_API void setSecondaryColors( unsigned int    fdim
00593                                       , const float   * cols
00594                                       , size_t          count
00595                                       );
00596
00598
00611       NVSG_API void setSecondaryColors( unsigned int    fdim
00612                                       , size_t          pos
00613                                       , const float   * cols
00614                                       , size_t          count
00615                                       );
00616
00618
00619       NVSG_API size_t getNumberOfFogCoords( void ) const;
00620
00622
00623       NVSG_API const float * getFogCoords( void ) const;
00624
00626
00629       NVSG_API void setFogCoords( const float * coords
00630                                 , size_t        count
00631                                 );
00632
00634
00645       NVSG_API void setFogCoords( size_t        pos
00646                                 , const float * coords
00647                                 , size_t        count
00648                                 );
00649
00651
00652       NVSG_API size_t getNumberOfOwners( void ) const;
00653
00655
00656       NVSG_API const PrimitiveSet * getOwner( size_t index
00657                                          ) const;
00658
00660
00661       NVSG_API VertexAttributeSet & operator=(const VertexAttributeSet & rhs);
00662
00664
00665       NVSG_API virtual bool isEquivalent( const Object *p
00666                                         , bool ignoreNames
00667                                         , bool deepCompare
00668                                         ) const;
00669
00670     protected:
00672       NVSG_API VertexAttributeSet(void);
00673
00675       NVSG_API VertexAttributeSet( const VertexAttributeSet &rhs );
00676
00678       NVSG_API virtual ~VertexAttributeSet(void);
00679
00681
00685       NVSG_API virtual void invalidateIncarnation( void );      // from bottom to top
00686
00687     private:
00688       friend class PrimitiveSet;
00689       NVSG_API void addOwner( const PrimitiveSet * p );
00690       NVSG_API void removeOwner( const PrimitiveSet * p );
00691
00692       void releaseCachedData();
00693
00694     private:
00695       std::vector<const PrimitiveSet *>                 m_owners;
00696
00697       unsigned int                                      m_formatBits;
00698       nvutil::RCPtr<nvutil::RCVector<VertexAttribute> > m_vertexAttributes;    // shareable vertex attribs
00699   };
00700
00701
00703
00704   typedef enum
00705   {
00706     TCT_CYLINDRICAL,
00707     TCT_PLANAR,
00708     TCT_SPHERICAL,
00709   } TextureCoordType;
00710
00718   NVSG_API void generateTexCoords( VertexAttributeSet * vas
00719                                  , TextureCoordType tct
00720                                  , const nvmath::Sphere3f &sphere
00721                                  , size_t tu = 0
00722                                  );
00723
00724
00725   inline unsigned int VertexAttributeSet::getInterleavedFormat() const
00726   {
00727     NVSG_TRACE();
00728     return m_formatBits;
00729   }
00730
00731   inline const float * VertexAttributeSet::getVertexAttributeData( size_t attrib ) const
00732   {
00733     NVSG_TRACE();
00734     NVSG_ASSERT(attrib < NUMBER_OF_VERTEX_ATTRIBUTES );
00735     return( (*m_vertexAttributes)[attrib].getData() );
00736   }
00737
00738   inline size_t VertexAttributeSet::getNumberOfVertexAttributeData( size_t attrib ) const
00739   {
00740     NVSG_TRACE();
00741     NVSG_ASSERT(attrib < NUMBER_OF_VERTEX_ATTRIBUTES);
00742     return( (*m_vertexAttributes)[attrib].getNumberOfData() );
00743   }
00744
00745   inline unsigned int VertexAttributeSet::getVertexAttributeDataDim( size_t attrib ) const
00746   {
00747     NVSG_TRACE();
00748     NVSG_ASSERT(attrib < NUMBER_OF_VERTEX_ATTRIBUTES );
00749     return( (*m_vertexAttributes)[attrib].getDataDimension() );
00750   }
00751
00752   inline size_t VertexAttributeSet::getNumberOfVertices( void ) const
00753   {
00754     NVSG_TRACE();
00755     return getNumberOfVertexAttributeData(VERTEX_POSITION);
00756   }
00757
00758   inline const nvmath::Vec3f * VertexAttributeSet::getVertices( void )  const
00759   {
00760     NVSG_TRACE();
00761     return (const nvmath::Vec3f *)getVertexAttributeData(VERTEX_POSITION);
00762   }
00763
00764   inline void VertexAttributeSet::setVertices( const nvmath::Vec3f * verts, size_t count )
00765   {
00766     NVSG_TRACE();
00767     setVertexAttributeData(VERTEX_POSITION, 3, (const float*)verts, count);
00768   }
00769
00770   inline void VertexAttributeSet::setVertices( size_t pos, const nvmath::Vec3f * verts, size_t count )
00771   {
00772     NVSG_TRACE();
00773     setVertexAttributeData(VERTEX_POSITION, 3, pos, (const float*)verts, count);
00774   }
00775
00776   inline size_t VertexAttributeSet::getNumberOfNormals( void ) const
00777   {
00778     NVSG_TRACE();
00779     return getNumberOfVertexAttributeData(NORMAL);
00780   }
00781
00782   inline const nvmath::Vec3f * VertexAttributeSet::getNormals( void ) const
00783   {
00784     NVSG_TRACE();
00785     return (const nvmath::Vec3f *)getVertexAttributeData(NORMAL);
00786   }
00787
00788   inline void VertexAttributeSet::setNormals( const nvmath::Vec3f * nor, size_t count )
00789   {
00790     NVSG_TRACE();
00791     setVertexAttributeData(NORMAL, 3, (const float*)nor, count);
00792     //^ normals always are 3-dimensional
00793   }
00794
00795   inline void VertexAttributeSet::setNormals( size_t pos, const nvmath::Vec3f * nor, size_t count )
00796   {
00797     NVSG_TRACE();
00798     setVertexAttributeData(NORMAL, 3, pos, (const float*)nor, count );
00799   }
00800
00801   inline bool VertexAttributeSet::hasTexCoords( void ) const
00802   {
00803     NVSG_TRACE();
00804     return(  getNumberOfVertexAttributeData(TEXTURE_COORD_0)
00805           || getNumberOfVertexAttributeData(TEXTURE_COORD_1)
00806           || getNumberOfVertexAttributeData(TEXTURE_COORD_2)
00807           || getNumberOfVertexAttributeData(TEXTURE_COORD_3)
00808           || getNumberOfVertexAttributeData(TEXTURE_COORD_4)
00809           || getNumberOfVertexAttributeData(TEXTURE_COORD_5)
00810           || getNumberOfVertexAttributeData(TEXTURE_COORD_6)
00811           || getNumberOfVertexAttributeData(TEXTURE_COORD_7) );
00812   }
00813
00814   inline size_t VertexAttributeSet::getNumberOfTexCoords( size_t texUnit ) const
00815   {
00816     NVSG_TRACE();
00817     NVSG_ASSERT(texUnit <= 7);
00818     return getNumberOfVertexAttributeData(TEXTURE_COORD_0+texUnit);
00819   }
00820
00821   inline const float * VertexAttributeSet::getTexCoords( size_t texUnit ) const
00822   {
00823     NVSG_TRACE();
00824     NVSG_ASSERT(texUnit <= 7);
00825     return getVertexAttributeData(TEXTURE_COORD_0+texUnit);
00826   }
00827
00828   inline unsigned int VertexAttributeSet::getTexCoordsDim( size_t texUnit ) const
00829   {
00830     NVSG_TRACE();
00831     NVSG_ASSERT(texUnit <= 7);
00832     return getVertexAttributeDataDim(TEXTURE_COORD_0+texUnit);
00833   }
00834
00835   inline void VertexAttributeSet::clearTexCoords( size_t texUnit )
00836   {
00837     NVSG_TRACE();
00838     NVSG_ASSERT(texUnit <= 7);
00839     clearVertexAttributeData(TEXTURE_COORD_0+texUnit);
00840   }
00841
00842   inline void VertexAttributeSet::setTexCoords( size_t texUnit, unsigned int fdim, const float* coords, size_t count )
00843   {
00844     NVSG_TRACE();
00845     NVSG_ASSERT(texUnit <= 7);
00846     setVertexAttributeData(TEXTURE_COORD_0+texUnit, fdim, coords, count);
00847   }
00848
00849   inline void VertexAttributeSet::setTexCoords( size_t texUnit, unsigned int fdim, size_t pos, const float* coords, size_t count )
00850   {
00851     NVSG_TRACE();
00852     NVSG_ASSERT(texUnit <= 7);
00853     setVertexAttributeData(TEXTURE_COORD_0+texUnit, fdim, pos, coords, count);
00854   }
00855
00856   inline size_t VertexAttributeSet::getNumberOfColors( void ) const
00857   {
00858     NVSG_TRACE();
00859     return getNumberOfVertexAttributeData(PRIMARY_COLOR);
00860   }
00861
00862   inline const float * VertexAttributeSet::getColors( void ) const
00863   {
00864     NVSG_TRACE();
00865     return getVertexAttributeData(PRIMARY_COLOR);
00866   }
00867
00868   inline unsigned int VertexAttributeSet::getColorsDim( void ) const
00869   {
00870     NVSG_TRACE();
00871     return getVertexAttributeDataDim(PRIMARY_COLOR);
00872   }
00873
00874   inline void VertexAttributeSet::setColors( unsigned int fdim, const float * cols, size_t count )
00875   {
00876     NVSG_TRACE();
00877     setVertexAttributeData(PRIMARY_COLOR, fdim, cols, count);
00878   }
00879
00880   inline void VertexAttributeSet::setColors( unsigned int fdim, size_t pos, const float * cols, size_t count )
00881   {
00882     NVSG_TRACE();
00883     setVertexAttributeData(PRIMARY_COLOR, fdim, pos, cols, count);
00884   }
00885
00886   inline size_t VertexAttributeSet::getNumberOfSecondaryColors( void ) const
00887   {
00888     NVSG_TRACE();
00889     return getNumberOfVertexAttributeData(SECONDARY_COLOR);
00890   }
00891
00892   inline const float * VertexAttributeSet::getSecondaryColors( void ) const
00893   {
00894     NVSG_TRACE();
00895     return getVertexAttributeData(SECONDARY_COLOR);
00896   }
00897
00898   inline unsigned int VertexAttributeSet::getSecondaryColorsDim( void ) const
00899   {
00900     NVSG_TRACE();
00901     return getVertexAttributeDataDim(SECONDARY_COLOR);
00902   }
00903
00904   inline void VertexAttributeSet::setSecondaryColors( unsigned int fdim, const float* cols, size_t count )
00905   {
00906     NVSG_TRACE();
00907     setVertexAttributeData(SECONDARY_COLOR, fdim, cols, count);
00908   }
00909
00910   inline void VertexAttributeSet::setSecondaryColors( unsigned int fdim, size_t pos, const float* cols, size_t count )
00911   {
00912     NVSG_TRACE();
00913     setVertexAttributeData(SECONDARY_COLOR, fdim, pos, cols, count);
00914   }
00915
00916   inline size_t VertexAttributeSet::getNumberOfFogCoords( void ) const
00917   {
00918     NVSG_TRACE();
00919     return getNumberOfVertexAttributeData(FOG_COORDINATE);
00920   }
00921
00922   inline const float * VertexAttributeSet::getFogCoords( void ) const
00923   {
00924     NVSG_TRACE();
00925     return getVertexAttributeData(FOG_COORDINATE);
00926   }
00927
00928   inline void VertexAttributeSet::setFogCoords( const float * coords, size_t count )
00929   {
00930     NVSG_TRACE();
00931     setVertexAttributeData(FOG_COORDINATE, 1, coords, count);
00932     //^ fog coords always are 1-dimensional
00933   }
00934
00935   inline void VertexAttributeSet::setFogCoords( size_t pos, const float * coords, size_t count )
00936   {
00937     NVSG_TRACE();
00938     setVertexAttributeData(FOG_COORDINATE, 1, pos, coords, count);
00939     //^ fog coords always are 1-dimensional
00940   }
00941
00942   inline size_t VertexAttributeSet::getNumberOfOwners( void ) const
00943   {
00944     NVSG_TRACE();
00945     return( m_owners.size() );
00946   }
00947
00948   inline const PrimitiveSet * VertexAttributeSet::getOwner( size_t index ) const
00949   {
00950     NVSG_TRACE();
00951     NVSG_ASSERT( index < m_owners.size() );
00952     return( m_owners[index] );
00953   }
00954 } //  namespace nvsg
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA


VertexUnifyTraverser.h File Reference

#include "nvsgcommon.h"
#include <set>
#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 Fri Aug 4 08:36:23 2006 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 "nvsgcommon.h"
00016
00017 #include <set>
00018 #include "nvsg/nvsg.h"
00019 #include "nvtraverser/OptimizeTraverser.h"
00020
00021 namespace nvtraverser
00022 {
00023
00025
00027   class VertexUnifyTraverser : public OptimizeTraverser
00028   {
00029     public:
00031       NVSG_API VertexUnifyTraverser(void);
00032
00034
00035       NVSG_API void  setEpsilon( float epsilon
00036                                );
00037
00038     protected:
00040       NVSG_API virtual ~VertexUnifyTraverser(void);
00041
00043
00044       NVSG_API virtual void  doApply( const nvsg::Scene * scene
00045                                     );
00046
00048       void  handleVertexAttributeSet( const nvsg::VertexAttributeSet * p );
00049
00051       void  handleAnimatedQuads( const nvsg::AnimatedQuads * p );
00052       void  handleAnimatedTriangles( const nvsg::AnimatedTriangles * p );
00053       void  handleSkinnedTriangles( const nvsg::SkinnedTriangles * p );
00054
00055     private:
00056       float                                         m_epsilon;
00057       float                                         m_tolerance;
00058       std::set<const nvsg::VertexAttributeSet *>    m_multiOwnedHandledVAS;
00059       std::vector<const nvsg::VertexAttributeSet*>  m_removedVAS;
00060   };
00061
00062   inline  void  VertexUnifyTraverser::setEpsilon( float epsilon )
00063   {
00064     m_epsilon = fabsf( epsilon );
00065   }
00066 }
Generated on Fri Aug 4 08:33:10 2006 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 Fri Aug 4 08:36:24 2006 for NVSGSDK by NVIDIA


ViewState.h Source File

ViewState.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/Camera.h"
00018 #include "nvsg/MapList.h"
00019
00020 namespace nvsg
00021 {
00022   class CullData;
00023
00061   class ViewState : public nvutil::RCObject
00062                   , public nvutil::ISWMRSync
00063   {
00064     public:
00074       NVSG_API static const ViewState * create();
00075
00082       NVSG_API const ViewState * clone() const;
00083
00088       NVSG_API void setAnimationFrame(size_t frame );
00089
00094       NVSG_API size_t getAnimationFrame() const;
00095
00100       NVSG_API bool isAnimating() const;
00101
00141       NVSG_API void setAnimation(bool state);
00142
00147       NVSG_API void setCamera(const Camera * camera);
00148
00153       NVSG_API const Camera * getCamera() const;
00154
00161       NVSG_API bool isJitter() const;
00162
00168       NVSG_API size_t getNumberOfJitters() const;
00169
00197       NVSG_API void setJitter(bool on, const std::vector<nvmath::Vec2f> &jitters);
00198
00206       NVSG_API const nvmath::Vec2f * getJitters() const;
00207
00212       NVSG_API float getTargetDistance() const;
00213
00218       NVSG_API void setTargetDistance(float dist);
00219
00223       NVSG_API bool isStereo() const;
00224
00230       NVSG_API void setStereo(bool state);
00231
00235       NVSG_API void toggleStereo();
00236
00244       NVSG_API bool isStereoAutomaticEyeDistanceAdjustment() const;
00245
00252       NVSG_API void setStereoAutomaticEyeDistanceAdjustment(bool state);
00253
00261       NVSG_API float getStereoAutomaticEyeDistanceFactor() const;
00262
00273       NVSG_API void setStereoAutomaticEyeDistanceFactor(float factor);
00274
00285       NVSG_API float getStereoEyeDistance() const;
00286
00293       NVSG_API void setStereoEyeDistance(float distance);
00294
00298       NVSG_API void stereoReverseEyes();
00299
00305       NVSG_API bool isStereoReversedEyes() const;
00306
00316       NVSG_API void setLODRangeScale(float factor);
00317
00319
00328       NVSG_API float getLODRangeScale() const;
00329
00336       NVSG_API void clearCullTree() const ;
00337
00346       NVSG_API const CullData * getCullTree() const;
00347
00355       NVSG_API void setCullTree( const CullData *cullTree );
00356
00365       NVSG_API const MapList * getMapList() const;
00366
00375       NVSG_API void setMapList( const MapList * ml );
00376
00377     protected:
00380       NVSG_API ViewState();
00381
00386       NVSG_API ViewState( const ViewState& rhs );
00387
00389       NVSG_API virtual ~ViewState();
00390
00391     private:
00392       // assigning a ViewState is not permitted!
00393       ViewState& operator=(const ViewState&);
00394
00395     private:
00396       size_t                        m_animationFrame;
00397       const Camera                * m_camera;
00398       bool                          m_jitterState;
00399       std::vector<nvmath::Vec2f>    m_jitters;
00400       float                         m_targetDistance;
00401       bool                          m_stereoState;
00402       bool                          m_stereoAutomaticEyeDistanceAdjustment;
00403       float                         m_stereoAutomaticEyeDistanceFactor;
00404       float                         m_stereoEyeDistance;
00405       bool                          m_reversedEyes;
00406       float                         m_scaleLODRange;
00407       // the animation state might be modified by concurrently executing threads,
00408       // declare it as volatile for this reason
00409       volatile bool                 m_animationState;
00410
00411       mutable const CullData      * m_cullTree;
00412
00413       const MapList * m_mapList;
00414   };
00415
00416
00417   inline size_t ViewState::getAnimationFrame() const
00418   {
00419     return( m_animationFrame );
00420   }
00421
00422   inline bool ViewState::isAnimating() const
00423   {
00424     return( m_animationState );
00425   }
00426
00427   inline const Camera * ViewState::getCamera() const
00428   {
00429     return( m_camera );
00430   }
00431
00432   inline void ViewState::setAnimationFrame( size_t frame )
00433   {
00434     m_animationFrame = frame;
00435   }
00436
00437   inline void ViewState::setAnimation( bool state )
00438   {
00439     m_animationState = state;
00440   }
00441
00442   inline void ViewState::setCamera( const Camera * pCamera )
00443   {
00444     if ( m_camera != pCamera )
00445     {
00446       if ( m_camera )
00447       {
00448         m_camera->removeRef();
00449       }
00450       m_camera = pCamera;
00451       if ( m_camera )
00452       {
00453         m_camera->addRef();
00454         if ( fabsf( m_targetDistance ) < FLT_EPSILON )
00455         {
00456           m_targetDistance = m_camera->getFocusDistance();
00457         }
00458       }
00459     }
00460   }
00461
00462   inline bool ViewState::isJitter() const
00463   {
00464     return( m_jitterState );
00465   }
00466
00467   inline size_t ViewState::getNumberOfJitters() const
00468   {
00469     return( m_jitters.size() );
00470   }
00471
00472   inline void ViewState::setJitter( bool bOn, const std::vector<nvmath::Vec2f> &jitters )
00473   {
00474     m_jitterState = bOn;
00475     m_jitters = jitters;
00476   }
00477
00478   inline const nvmath::Vec2f * ViewState::getJitters() const
00479   { // return address of first element or null if no elements available
00480     return( !m_jitters.empty() ? &m_jitters[0] : NULL );
00481   }
00482
00483   inline float ViewState::getTargetDistance() const
00484   {
00485     return( m_targetDistance );
00486   }
00487
00488   inline void ViewState::setTargetDistance( float dist )
00489   {
00490     m_targetDistance = dist;
00491   }
00492
00493   inline bool ViewState::isStereo() const
00494   {
00495     return( m_stereoState );
00496   }
00497
00498   inline void ViewState::setStereo( bool state )
00499   {
00500     m_stereoState = state;
00501   }
00502
00503   inline void ViewState::toggleStereo()
00504   {
00505     m_stereoState = ! m_stereoState;
00506   }
00507
00508   inline bool ViewState::isStereoAutomaticEyeDistanceAdjustment() const
00509   {
00510     return( m_stereoAutomaticEyeDistanceAdjustment );
00511   }
00512
00513   inline void ViewState::setStereoAutomaticEyeDistanceAdjustment( bool state )
00514   {
00515     m_stereoAutomaticEyeDistanceAdjustment = state;
00516   }
00517
00518   inline float ViewState::getStereoAutomaticEyeDistanceFactor() const
00519   {
00520     return( m_stereoAutomaticEyeDistanceFactor );
00521   }
00522
00523   inline void ViewState::setStereoAutomaticEyeDistanceFactor( float factor )
00524   {
00525     m_stereoAutomaticEyeDistanceFactor = factor;
00526   }
00527
00528   inline float ViewState::getStereoEyeDistance() const
00529   {
00530     if (m_stereoAutomaticEyeDistanceAdjustment)
00531     {
00532       NVSG_ASSERT(m_camera);
00533       return(m_stereoAutomaticEyeDistanceFactor * m_camera->getFocusDistance());
00534     }
00535     else
00536     {
00537       return(m_stereoEyeDistance);
00538     }
00539
00540   }
00541
00542   inline void ViewState::setStereoEyeDistance( float distance )
00543   {
00544     m_stereoEyeDistance = distance;
00545   }
00546
00547   inline void ViewState::stereoReverseEyes()
00548   {
00549     m_reversedEyes = !m_reversedEyes;
00550   }
00551
00552   inline bool ViewState::isStereoReversedEyes() const
00553   {
00554     return( m_reversedEyes );
00555   }
00556
00557   inline const CullData * ViewState::getCullTree() const
00558   {
00559     return( m_cullTree );
00560   }
00561
00562   inline void ViewState::setCullTree( const CullData *cullTree )
00563   {
00564     clearCullTree();
00565     m_cullTree = cullTree;
00566   }
00567
00568   inline void ViewState::setLODRangeScale(float factor)
00569   {
00570     m_scaleLODRange = factor;
00571   }
00572
00573   inline float ViewState::getLODRangeScale() const
00574   {
00575     return m_scaleLODRange;
00576   }
00577
00578   inline const MapList * ViewState::getMapList() const
00579   {
00580     return( m_mapList );
00581   }
00582
00583   inline void ViewState::setMapList( const MapList * ml )
00584   {
00585     if ( ml )
00586     {
00587       ml->addRef();
00588     }
00589     if ( m_mapList )
00590     {
00591       m_mapList->removeRef();
00592     }
00593     m_mapList = ml;
00594   }
00595
00596 } // namespace
Generated on Fri Aug 4 08:33:11 2006 for NVSGSDK by NVIDIA


VNVector.h File Reference

#include "nvsgcommon.h"
#include "nvmath/nvmath.h"
#include "nvmath/Vec3f.h"

Include dependency graph for VNVector.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 Fri Aug 4 08:36:25 2006 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
00017 #include  "nvmath/nvmath.h"
00018 #include  "nvmath/Vec3f.h"
00019
00020 namespace nvsg
00021 {
00027   class VNVector
00028   {
00029     public:
00031
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
00046 namespace nvmath
00047 {
00049
00053   inline nvsg::VNVector lerp( float alpha
00054                             , const nvsg::VNVector &v0
00055                             , const nvsg::VNVector &v1
00056                             )
00057   {
00058     nvsg::VNVector  vnv;
00059
00060     NVSG_ASSERT( v0.vertices.size() == v1.vertices.size() );
00061     vnv.vertices.resize( v0.vertices.size() );
00062     for ( size_t i=0 ; i<v0.vertices.size() ; i++ )
00063     {
00064       vnv.vertices[i] = lerp( alpha, v0.vertices[i], v1.vertices[i] );
00065                       //^^^^ invoke general lerp template
00066     }
00067
00068     NVSG_ASSERT( v0.normals.size()  == v1.normals.size() );
00069     vnv.normals.resize( v0.normals.size() );
00070     for ( size_t i=0 ; i<v0.normals.size() ; i++ )
00071     {
00072       vnv.normals[i] = normalize( lerp( alpha, v0.normals[i], v1.normals[i] ) );
00073                                 //^^^^ invoke general lerp template
00074     }
00075
00076     return( vnv );
00077   }
00078 }
Generated on Fri Aug 4 08:33:11 2006 for NVSGSDK by NVIDIA


VRMLTypes.h File Reference

#include "nvmath/Quatf.h"
#include "nvmath/Vec2f.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

Defines

#define | USE_QUAD_MESHES_FOR_ELEVATION_GRID 0

Detailed Description

Generated on Fri Aug 4 08:36:26 2006 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/Quatf.h"
00016 #include  "nvmath/Vec2f.h"
00017 #include  "nvsg/Object.h"
00018
00019 #define USE_QUAD_MESHES_FOR_ELEVATION_GRID  0
00020
00021 namespace nvsg
00022 {
00023   class Billboard;
00024   class DirectedLight;
00025   class GeoNode;
00026   class Group;
00027   class LineStrips;
00028   class LOD;
00029   class Material;
00030   class Node;
00031   class PointLight;
00032   class Points;
00033   class QuadMeshes;
00034   class Quads;
00035   class SpotLight;
00036   class StateSet;
00037   class Switch;
00038   class TextureAttribute;
00039   class Transform;
00040   class Triangles;
00041 }
00042
00043 namespace vrml
00044 {
00045
00046   //  it's not neccessary to document all these helper classes !
00047 #if ! defined( DOXYGEN_IGNORE )
00048
00049   class Object : public nvsg::Object
00050   {
00051     public:
00052       virtual ~Object() {}
00053       virtual const std::string & getType( void ) const;
00054   };
00055
00056   typedef bool                SFBool;
00057   typedef nvmath::Vec3f               SFColor;
00058   typedef std::vector<SFColor>     MFColor;
00059   typedef float               SFFloat;
00060   typedef std::vector<SFFloat>     MFFloat;
00061   typedef char                SFInt8;
00062   typedef int                 SFInt32;
00063   typedef std::vector<SFInt32>     MFInt32;
00064   typedef vrml::Object  *     SFNode;
00065   typedef std::vector<SFNode>      MFNode;
00066   typedef std::string              SFString;
00067   typedef std::vector<SFString>    MFString;
00068   typedef double              SFTime;
00069   typedef std::vector<SFTime>      MFTime;
00070   typedef nvmath::Vec2f               SFVec2f;
00071   typedef std::vector<SFVec2f>     MFVec2f;
00072   typedef nvmath::Vec3f               SFVec3f;
00073   typedef std::vector<SFVec3f>     MFVec3f;
00074
00075   class SFImage
00076   {
00077     public:
00078       SFImage();
00079       ~SFImage();
00080
00081     public:
00082       SFInt32   width;
00083       SFInt32   height;
00084       SFInt32   numComponents;
00085       SFInt8  * pixelsValues;
00086   };
00087
00088   class SFRotation : public nvmath::Vec4f
00089   {
00090     public:
00091       SFRotation()  {}
00092       SFRotation( const SFVec3f &axis, SFFloat angle );
00093       SFRotation( const nvmath::Vec4f &v )
00094         : nvmath::Vec4f( v )
00095       {
00096       }
00097   };
00098   typedef std::vector<SFRotation>  MFRotation;
00099
00100   class Geometry : public Object
00101   {
00102     public:
00103       virtual ~Geometry() {}
00104       virtual const std::string & getType( void ) const;
00105   };
00106
00107   class Group : public Object
00108   {
00109     public:
00110       Group();
00111       virtual ~Group();
00112       virtual const std::string & getType( void ) const;
00113
00114     public:
00115       SFVec3f bboxCenter;
00116       SFVec3f bboxSize;
00117       MFNode  children;
00118
00119       const nvsg::Group * pGroup;
00120   };
00121
00122   class Interpolator : public Object
00123   {
00124     public:
00125       virtual ~Interpolator()  {}
00126       virtual const std::string & getType( void ) const;
00127
00128     public:
00129       MFFloat key;
00130   };
00131
00132   class Light : public Object
00133   {
00134     public:
00135       Light();
00136       virtual ~Light()  {}
00137       virtual const std::string & getType( void ) const;
00138
00139     public:
00140       SFFloat ambientIntensity;
00141       SFColor color;
00142       SFFloat intensity;
00143       SFBool  on;
00144   };
00145
00146   class Sensor : public Object
00147   {
00148     public:
00149       Sensor();
00150       virtual ~Sensor()  {}
00151       virtual const std::string & getType( void ) const;
00152
00153     public:
00154       SFBool  enabled;
00155   };
00156
00157   class Texture : public Object
00158   {
00159     public:
00160       Texture();
00161       virtual ~Texture()  {}
00162       virtual const std::string & getType( void ) const;
00163
00164     public:
00165       SFBool  repeatS;
00166       SFBool  repeatT;
00167   };
00168
00169   class Anchor : public Group
00170   {
00171     public:
00172       virtual ~Anchor() {}
00173       virtual const std::string & getType( void ) const;
00174
00175     public:
00176       SFString  description;
00177       MFString  parameter;
00178       MFString  url;
00179   };
00180
00181   class Appearance : public Object
00182   {
00183     public:
00184       Appearance();
00185       virtual ~Appearance();
00186       virtual const std::string & getType( void ) const;
00187
00188     public:
00189       SFNode  material;
00190       SFNode  texture;
00191       SFNode  textureTransform;
00192
00193       const nvsg::StateSet  * pStateSet;
00194   };
00195
00196   class AudioClip : public Object
00197   {
00198     public:
00199       AudioClip();
00200       virtual ~AudioClip()  {}
00201       virtual const std::string & getType( void ) const;
00202
00203     public:
00204       SFString  description;
00205       SFBool    loop;
00206       SFFloat   pitch;
00207       SFTime    startTime;
00208       SFTime    stopTime;
00209       MFString  url;
00210   };
00211
00212   class Background : public Object
00213   {
00214     public:
00215       Background();
00216       virtual ~Background() {}
00217       virtual const std::string & getType( void ) const;
00218
00219     public:
00220       MFFloat   groundAngle;
00221       MFColor   groundColor;
00222       MFString  backUrl;
00223       MFString  bottomUrl;
00224       MFString  frontUrl;
00225       MFString  leftUrl;
00226       MFString  rightUrl;
00227       MFString  topUrl;
00228       MFFloat   skyAngle;
00229       MFColor   skyColor;
00230   };
00231
00232   class Billboard : public Group
00233   {
00234     public:
00235       Billboard();
00236       virtual ~Billboard();
00237       virtual const std::string & getType( void ) const;
00238
00239     public:
00240       SFVec3f axisOfRotation;
00241
00242       const nvsg::Billboard * pBillboard;
00243   };
00244
00245   class Box : public Geometry
00246   {
00247     public:
00248       Box();
00249       virtual ~Box();
00250       virtual const std::string & getType( void ) const;
00251
00252     public:
00253       SFVec3f size;
00254
00255       const nvsg::Triangles * pTriangles;
00256       const nvsg::Quads     * pQuads;
00257   };
00258
00259   class Collision : public Group
00260   {
00261     public:
00262       Collision();
00263       virtual ~Collision();
00264       virtual const std::string & getType( void ) const;
00265
00266     public:
00267       SFBool  collide;
00268       SFNode  proxy;
00269   };
00270
00271   class Color : public Object
00272   {
00273     public:
00274       virtual ~Color() {}
00275       virtual const std::string & getType( void ) const;
00276
00277     public:
00278       MFColor color;
00279   };
00280
00281   class ColorInterpolator : public Interpolator
00282   {
00283     public:
00284       virtual ~ColorInterpolator()  {}
00285       virtual const std::string & getType( void ) const;
00286
00287     public:
00288       MFColor keyValue;
00289   };
00290
00291   class Cone : public Geometry
00292   {
00293     public:
00294       Cone();
00295       virtual ~Cone() {}
00296       virtual const std::string & getType( void ) const;
00297
00298     public:
00299       SFBool  bottom;
00300       SFFloat bottomRadius;
00301       SFFloat height;
00302       SFBool  side;
00303   };
00304
00305   class CoordinateInterpolator : public Interpolator
00306   {
00307     public:
00308       virtual ~CoordinateInterpolator()  {}
00309       virtual const std::string & getType( void ) const;
00310
00311     public:
00312       MFVec3f keyValue;
00313   };
00314
00315   class Coordinate : public Object
00316   {
00317     public:
00318       Coordinate();
00319       virtual ~Coordinate();
00320       virtual const std::string & getType( void ) const;
00321
00322     public:
00323       MFVec3f point;
00324
00325       CoordinateInterpolator  * set_point;
00326   };
00327
00328   class Cylinder : public Geometry
00329   {
00330     public:
00331       Cylinder();
00332       virtual ~Cylinder() {}
00333       virtual const std::string & getType( void ) const;
00334
00335     public:
00336       SFBool  bottom;
00337       SFFloat height;
00338       SFFloat radius;
00339       SFBool  side;
00340       SFBool  top;
00341   };
00342
00343   class CylinderSensor : public Sensor
00344   {
00345     public:
00346       CylinderSensor();
00347       virtual ~CylinderSensor()  {}
00348       virtual const std::string & getType( void ) const;
00349
00350     public:
00351       SFBool  autoOffset;
00352       SFFloat diskAngle;
00353       SFFloat maxAngle;
00354       SFFloat minAngle;
00355       SFFloat offset;
00356   };
00357
00358   class DirectionalLight : public Light
00359   {
00360     public:
00361       DirectionalLight();
00362       virtual ~DirectionalLight();
00363       virtual const std::string & getType( void ) const;
00364
00365     public:
00366       SFVec3f direction;
00367
00368       const nvsg::DirectedLight * pDirectedLight;
00369   };
00370
00371   class ElevationGrid : public Geometry
00372   {
00373     public:
00374       ElevationGrid();
00375       virtual ~ElevationGrid();
00376       virtual const std::string & getType( void ) const;
00377
00378     public:
00379       SFNode  color;
00380       SFNode  normal;
00381       SFNode  texCoord;
00382       MFFloat height;
00383       SFBool  ccw;
00384       SFBool  colorPerVertex;
00385       SFFloat creaseAngle;
00386       SFBool  normalPerVertex;
00387       SFBool  solid;
00388       SFInt32 xDimension;
00389       SFFloat xSpacing;
00390       SFInt32 zDimension;
00391       SFFloat zSpacing;
00392
00393 #if USE_QUAD_MESHES_FOR_ELEVATION_GRID
00394       const nvsg::QuadMeshes * pQuadMeshes;
00395 #else
00396       const nvsg::Triangles * pTriangles;
00397       const nvsg::Quads     * pQuads;
00398 #endif
00399   };
00400
00401   class Extrusion : public Geometry
00402   {
00403     public:
00404       Extrusion();
00405       virtual ~Extrusion()  {}
00406       virtual const std::string & getType( void ) const;
00407
00408     public:
00409       SFBool      beginCap;
00410       SFBool      ccw;
00411       SFBool      convex;
00412       SFFloat     creaseAngle;
00413       MFVec2f     crossSection;
00414       SFBool      endCap;
00415       MFRotation  orientation;
00416       MFVec2f     scale;
00417       SFBool      solid;
00418       MFVec3f     spine;
00419   };
00420
00421   class Fog : public Object
00422   {
00423     public:
00424       Fog();
00425       virtual ~Fog()  {}
00426       virtual const std::string & getType( void ) const;
00427
00428     public:
00429       SFColor   color;
00430       SFString  fogType;
00431       SFFloat   visibilityRange;
00432   };
00433
00434   class FontStyle : public Object
00435   {
00436     public:
00437       FontStyle();
00438       virtual ~FontStyle()  {}
00439       virtual const std::string & getType( void ) const;
00440
00441     public:
00442       MFString  family;
00443       SFBool    horizontal;
00444       MFString  justify;
00445       SFString  language;
00446       SFBool    leftToRight;
00447       SFFloat   size;
00448       SFFloat   spacing;
00449       SFString  style;
00450       SFBool    topToBottom;
00451   };
00452
00453   class ImageTexture : public Texture
00454   {
00455     public:
00456       ImageTexture();
00457       virtual ~ImageTexture();
00458       virtual const std::string & getType( void ) const;
00459
00460     public:
00461       MFString  url;
00462
00463       const nvsg::TextureAttribute  * pTextureAttribute;
00464   };
00465
00466   class IndexedFaceSet : public Geometry
00467   {
00468     public:
00469       IndexedFaceSet();
00470       virtual ~IndexedFaceSet();
00471       virtual const std::string & getType( void ) const;
00472
00473     public:
00474       SFNode  color;
00475       SFNode  coord;
00476       SFNode  normal;
00477       SFNode  texCoord;
00478       SFBool  ccw;
00479       MFInt32 colorIndex;
00480       SFBool  colorPerVertex;
00481       SFBool  convex;
00482       MFInt32 coordIndex;
00483       SFFloat creaseAngle;
00484       MFInt32 normalIndex;
00485       SFBool  normalPerVertex;
00486       SFBool  solid;
00487       MFInt32 texCoordIndex;
00488
00489       const nvsg::Triangles * pTriangles;
00490       const nvsg::Quads     * pQuads;
00491   };
00492
00493   class IndexedLineSet : public Geometry
00494   {
00495     public:
00496       IndexedLineSet();
00497       virtual ~IndexedLineSet();
00498       virtual const std::string & getType( void ) const;
00499
00500     public:
00501       SFNode  color;
00502       SFNode  coord;
00503       MFInt32 colorIndex;
00504       SFBool  colorPerVertex;
00505       MFInt32 coordIndex;
00506
00507       const nvsg::LineStrips * pLineStrips;
00508   };
00509
00510   class Inline : public Object
00511   {
00512     public:
00513       Inline();
00514       virtual ~Inline();
00515       virtual const std::string & getType( void ) const;
00516
00517     public:
00518       MFString  url;
00519       SFVec3f   bboxCenter;
00520       SFVec3f   bboxSize;
00521
00522       const nvsg::Node  * pNode;
00523   };
00524
00525   class LOD : public Group
00526   {
00527     public:
00528       LOD();
00529       virtual ~LOD();
00530       virtual const std::string & getType( void ) const;
00531
00532     public:
00533       SFVec3f center;
00534       MFFloat range;
00535
00536       const nvsg::LOD * pLOD;
00537   };
00538
00539   class Material : public Object
00540   {
00541     public:
00542       Material();
00543       virtual ~Material();
00544       virtual const std::string & getType( void ) const;
00545
00546     public:
00547       SFFloat ambientIntensity;
00548       SFColor diffuseColor;
00549       SFColor emissiveColor;
00550       SFFloat shininess;
00551       SFColor specularColor;
00552       SFFloat transparency;
00553
00554       const nvsg::Material *pMaterial;
00555   };
00556
00557   class MovieTexture : public Texture
00558   {
00559     public:
00560       MovieTexture();
00561       virtual ~MovieTexture()  {}
00562       virtual const std::string & getType( void ) const;
00563
00564     public:
00565       SFBool    loop;
00566       SFFloat   speed;
00567       SFTime    startTime;
00568       SFTime    stopTime;
00569       MFString  url;
00570   };
00571
00572   class NavigationInfo : public Object
00573   {
00574     public:
00575       NavigationInfo();
00576       virtual ~NavigationInfo() {}
00577       virtual const std::string & getType( void ) const;
00578
00579     public:
00580       MFFloat   avatarSize;
00581       SFBool    headlight;
00582       SFFloat   speed;
00583       MFString  type;
00584       SFFloat   visibilityLimit;
00585   };
00586
00587   class NormalInterpolator : public Interpolator
00588   {
00589     public:
00590       virtual ~NormalInterpolator()  {}
00591       virtual const std::string & getType( void ) const;
00592
00593     public:
00594       MFVec3f keyValue;
00595   };
00596
00597   class Normal : public Object
00598   {
00599     public:
00600       Normal();
00601       virtual ~Normal();
00602       virtual const std::string & getType( void ) const;
00603
00604     public:
00605       MFVec3f vector;
00606
00607       NormalInterpolator  * set_vector;
00608   };
00609
00610   class OrientationInterpolator : public Interpolator
00611   {
00612     public:
00613       virtual ~OrientationInterpolator()  {}
00614       virtual const std::string & getType( void ) const;
00615
00616     public:
00617       MFRotation  keyValue;
00618
00619       std::vector<nvmath::Quatf> keyValueQuatf;
00620   };
00621
00622   class PixelTexture : public Texture
00623   {
00624     public:
00625       PixelTexture();
00626       virtual ~PixelTexture()  {}
00627       virtual const std::string & getType( void ) const;
00628
00629     public:
00630       SFImage image;
00631   };
00632
00633   class PlaneSensor : public Sensor
00634   {
00635     public:
00636       PlaneSensor();
00637       virtual ~PlaneSensor()  {}
00638       virtual const std::string & getType( void ) const;
00639
00640     public:
00641       SFBool  autoOffset;
00642       SFVec2f maxPosition;
00643       SFVec2f minPosition;
00644       SFVec3f offset;
00645   };
00646
00647   class PointLight : public Light
00648   {
00649     public:
00650       PointLight();
00651       virtual ~PointLight();
00652       virtual const std::string & getType( void ) const;
00653
00654     public:
00655       SFVec3f attenuation;
00656       SFVec3f location;
00657       SFFloat radius;
00658
00659       const nvsg::PointLight  * pPointLight;
00660   };
00661
00662   class PointSet : public Geometry
00663   {
00664     public:
00665       PointSet();
00666       virtual ~PointSet();
00667       virtual const std::string & getType( void ) const;
00668
00669     public:
00670       SFNode  color;
00671       SFNode  coord;
00672
00673       const nvsg::Points * pPoints;
00674   };
00675
00676   class PositionInterpolator : public Interpolator
00677   {
00678     public:
00679       virtual ~PositionInterpolator()  {}
00680       virtual const std::string & getType( void ) const;
00681
00682     public:
00683       MFVec3f keyValue;
00684   };
00685
00686   class ProximitySensor : public Sensor
00687   {
00688     public:
00689       ProximitySensor();
00690       virtual ~ProximitySensor()  {}
00691       virtual const std::string & getType( void ) const;
00692
00693     public:
00694       SFVec3f center;
00695       SFVec3f size;
00696   };
00697
00698   class ScalarInterpolator : public Interpolator
00699   {
00700     public:
00701       virtual ~ScalarInterpolator()  {}
00702       virtual const std::string & getType( void ) const;
00703
00704     public:
00705       MFFloat keyValue;
00706   };
00707
00708   class Script : public Object
00709   {
00710     public:
00711       Script();
00712       virtual ~Script() {}
00713       virtual const std::string & getType( void ) const;
00714
00715     public:
00716       MFString  url;
00717       SFBool    directOutput;
00718       SFBool    mustEvaluate;
00719   };
00720
00721   class Shape : public Object
00722   {
00723     public:
00724       Shape();
00725       virtual ~Shape();
00726       virtual const std::string & getType( void ) const;
00727
00728     public:
00729       SFNode  appearance;
00730       SFNode  geometry;
00731
00732       const nvsg::GeoNode * pGeoNode;
00733   };
00734
00735   class Sound : public Object
00736   {
00737     public:
00738       Sound();
00739       virtual ~Sound();
00740       virtual const std::string & getType( void ) const;
00741
00742     public:
00743       SFVec3f direction;
00744       SFFloat intensity;
00745       SFVec3f location;
00746       SFFloat maxBack;
00747       SFFloat maxFront;
00748       SFFloat minBack;
00749       SFFloat minFront;
00750       SFFloat priority;
00751       SFNode  source;
00752       SFBool  spatialize;
00753   };
00754
00755   class Sphere : public Geometry
00756   {
00757     public:
00758       Sphere();
00759       virtual ~Sphere() {}
00760       virtual const std::string & getType( void ) const;
00761
00762     public:
00763       SFFloat radius;
00764   };
00765
00766   class SphereSensor : public Sensor
00767   {
00768     public:
00769       SphereSensor();
00770       virtual ~SphereSensor()  {}
00771       virtual const std::string & getType( void ) const;
00772
00773     public:
00774       SFBool      autoOffset;
00775       SFRotation  offset;
00776   };
00777
00778   class SpotLight : public Light
00779   {
00780     public:
00781       SpotLight();
00782       virtual ~SpotLight();
00783       virtual const std::string & getType( void ) const;
00784
00785     public:
00786       SFVec3f attenuation;
00787       SFFloat beamWidth;
00788       SFFloat cutOffAngle;
00789       SFVec3f direction;
00790       SFVec3f location;
00791       SFFloat radius;
00792
00793       const nvsg::SpotLight * pSpotLight;
00794   };
00795
00796   class Switch : public Group
00797   {
00798     public:
00799       Switch();
00800       virtual ~Switch();
00801       virtual const std::string & getType( void ) const;
00802
00803     public:
00804       SFInt32 whichChoice;
00805
00806       const nvsg::Switch  * pSwitch;
00807   };
00808
00809   class Text : public Geometry
00810   {
00811     public:
00812       Text();
00813       virtual ~Text();
00814       virtual const std::string & getType( void ) const;
00815
00816     public:
00817       MFString  string;
00818       SFNode    fontStyle;
00819       MFFloat   length;
00820       SFFloat   maxExtent;
00821   };
00822
00823   class TextureCoordinate : public Object
00824   {
00825     public:
00826       virtual ~TextureCoordinate()  {}
00827       virtual const std::string & getType( void ) const;
00828
00829     public:
00830       MFVec2f point;
00831   };
00832
00833   class TextureTransform : public Object
00834   {
00835     public:
00836       TextureTransform();
00837       virtual ~TextureTransform()  {}
00838       virtual const std::string & getType( void ) const;
00839
00840     public:
00841       SFVec2f center;
00842       SFFloat rotation;
00843       SFVec2f scale;
00844       SFVec2f translation;
00845   };
00846
00847   class TimeSensor : public Sensor
00848   {
00849     public:
00850       TimeSensor();
00851       virtual ~TimeSensor()  {}
00852       virtual const std::string & getType( void ) const;
00853
00854     public:
00855       SFTime  cycleInterval;
00856       SFBool  loop;
00857       SFTime  startTime;
00858       SFTime  stopTime;
00859   };
00860
00861   class TouchSensor : public Sensor
00862   {
00863     public:
00864       virtual ~TouchSensor()  {}
00865       virtual const std::string & getType( void ) const;
00866   };
00867
00868   class Transform : public Group
00869   {
00870     public:
00871       Transform();
00872       virtual ~Transform();
00873       virtual const std::string & getType( void ) const;
00874
00875     public:
00876       SFVec3f     center;
00877       SFRotation  rotation;
00878       SFVec3f     scale;
00879       SFRotation  scaleOrientation;
00880       SFVec3f     translation;
00881
00882       PositionInterpolator    * set_center;
00883       OrientationInterpolator * set_rotation;
00884       PositionInterpolator    * set_scale;
00885       PositionInterpolator    * set_translation;
00886
00887       const nvsg::Transform * pTransform;
00888   };
00889
00890   class Viewpoint : public Object
00891   {
00892     public:
00893       Viewpoint();
00894       virtual ~Viewpoint();
00895       virtual const std::string & getType( void ) const;
00896
00897     public:
00898       SFFloat     fieldOfView;
00899       SFBool      jump;
00900       SFRotation  orientation;
00901       SFVec3f     position;
00902       SFString    description;
00903
00904       OrientationInterpolator * set_orientation;
00905       PositionInterpolator    * set_position;
00906   };
00907
00908   class VisibilitySensor : public Sensor
00909   {
00910     public:
00911       VisibilitySensor();
00912       virtual ~VisibilitySensor()  {}
00913       virtual const std::string & getType( void ) const;
00914
00915     public:
00916       SFVec3f center;
00917       SFVec3f size;
00918   };
00919
00920   class WorldInfo : public Object
00921   {
00922     public:
00923       virtual ~WorldInfo()  {}
00924       virtual const std::string & getType( void ) const;
00925
00926     public:
00927       MFString  info;
00928       SFString  title;
00929   };
00930
00931
00932   class ROUTE
00933   {
00934     public:
00935       ROUTE();
00936       ~ROUTE();
00937
00938     public:
00939       SFNode  fromNode;
00940       std::string  fromAction;
00941       SFNode  toNode;
00942       std::string  toAction;
00943   };
00944
00945
00946   template  <typename T>  inline  bool  is( const Object *p )
00947   {
00948     return( dynamic_cast<const T *>( p ) != NULL );
00949   }
00950
00951 #endif  //  DOXYGEN_IGNORE
00952
00953 } //  namespace vrml
Generated on Fri Aug 4 08:33:11 2006 for NVSGSDK by NVIDIA


WalkCameraManipulator.h File Reference

#include "nvsgcommon.h"
#include "nvui/Manipulator.h"
#include "nvui/KeyInput.h"
#include "nvui/MouseInput.h"
#include "nvmath/Vec3f.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 Fri Aug 4 08:36:27 2006 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
00017 #include "nvui/Manipulator.h"
00018 #include "nvui/KeyInput.h"
00019 #include "nvui/MouseInput.h"
00020 #include "nvmath/Vec3f.h"
00021
00022 namespace nvui
00023 {
00024
00059   class WalkCameraManipulator : public Manipulator
00060   {
00061     public:
00071       NVSG_API WalkCameraManipulator(size_t screenSizeX = 1280, size_t screenSizeY = 1024);
00072
00074       NVSG_API ~WalkCameraManipulator();
00075
00077       enum
00078       { _NO_BTN_KEY         = 0x0000
00079       , _LEFT_MOUSE_BTN     = 0x0001
00080       , _MIDDLE_MOUSE_BTN   = 0x0002
00081       , _CONTROL_KEY        = 0x0004
00082       , _W_KEY              = 0x0008
00083       , _S_KEY              = 0x0010
00084       };
00085
00108       NVSG_API virtual bool updateFrame();
00109
00114       NVSG_API virtual bool isActive();
00115
00125       NVSG_API bool isWalk();
00126
00134       NVSG_API bool isTranslate();
00135
00143       NVSG_API bool isTilt();
00144
00152       void setWorldUpVector(nvmath::Vec3f up);
00153
00159       const nvmath::Vec3f& getWorldUpVector();
00160
00168       void setSpeedIncreaseFactor(float factor);
00169
00176       float getSpeedIncreaseFactor();
00177
00185       void setHSensitivity(float sensitivity);
00186
00194       float getHSensitivity();
00195
00200       void setSpeed(float speed);
00201
00205       float getSpeed();
00206
00216       void setScreenSize(UINT x, UINT y);
00217
00225       NVSG_API void reset();
00226
00233       NVSG_API void keyDown(UINT key);
00234
00241       NVSG_API void keyUp(UINT key);
00242
00253       NVSG_API void mouseButtonDown(UINT btn, int x, int y);
00254
00265       NVSG_API void mouseButtonUp(UINT btn, int x, int y);
00266
00273       NVSG_API void mouseMotion(int x, int y);
00274
00275     protected:
00277       static NVSG_API const UINT WALKFORWARD;
00279       static NVSG_API const UINT WALKBACKWARD;
00281       static NVSG_API const UINT TRANSLATE;
00283       static NVSG_API const UINT TILT;
00285       static NVSG_API const UINT INCREASESPEED;
00287       static NVSG_API const UINT DECREASESPEED;
00289       static NVSG_API const UINT AREAOFPEACE;
00290
00291       UINT  m_ScreenSizeX;
00292       UINT  m_ScreenSizeY;
00293
00294       nvmath::Vec3f m_worldUpVector;
00295       float m_speedIncreaseFactor;
00296       float m_hSensitivity;
00297       float m_speed;
00298
00299       nvui::MouseInput m_mouseInput;
00300       nvui::KeyInput   m_keyInput;
00301
00302     private:
00303       bool isWalkForward();
00304       bool isWalkBackward();
00305
00306       bool walk();
00307       bool translate();
00308       bool tilt();
00309   };
00310
00311   inline void WalkCameraManipulator::setScreenSize(UINT x, UINT y)
00312   {
00313     NVSG_ASSERT(x>0);
00314     NVSG_ASSERT(y>0);
00315     m_ScreenSizeX = x;
00316     m_ScreenSizeX = y;
00317   }
00318
00319   inline void WalkCameraManipulator::setWorldUpVector( nvmath::Vec3f up )
00320   {
00321     m_worldUpVector = up;
00322   }
00323
00324   inline const nvmath::Vec3f& WalkCameraManipulator::getWorldUpVector()
00325   {
00326     return m_worldUpVector;
00327   }
00328
00329   inline void WalkCameraManipulator::setSpeedIncreaseFactor(float factor)
00330   {
00331     NVSG_ASSERT(fabs(factor) > FLT_EPSILON);
00332     m_speedIncreaseFactor = factor;
00333   }
00334
00335   inline float WalkCameraManipulator::getSpeedIncreaseFactor()
00336   {
00337     return m_speedIncreaseFactor;
00338   }
00339
00340   inline void WalkCameraManipulator::setHSensitivity(float sensitivity)
00341   {
00342     m_hSensitivity = sensitivity;
00343   }
00344
00345   inline float WalkCameraManipulator::getHSensitivity()
00346   {
00347     return m_hSensitivity;
00348   }
00349
00350   inline void WalkCameraManipulator::setSpeed(float speed)
00351   {
00352     m_speed = speed;
00353   }
00354
00355   inline float WalkCameraManipulator::getSpeed()
00356   {
00357     return m_speed;
00358   }
00359 } //  namespace nvui
Generated on Fri Aug 4 08:33:11 2006 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.

Namespaces

namespace | nvsg

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 Fri Aug 4 08:36:28 2006 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 // Forward declarations
00027 namespace nvsg
00028 {
00029   class Billboard;
00030   class DirectedLight;
00031   class Drawable;
00032   class GeoNode;
00033   class GeoSet;
00034   class Group;
00035   class LOD;
00036   class Material;
00037   class PointLight;
00038   class SpotLight;
00039   class StateSet;
00040   class Switch;
00041   class TextureAttribute;
00042   class Transform;
00043   class VertexAttributeSet;
00044   class VNVector;
00045   template<typename T> class LinearInterpolatedAnimation;
00046 }
00047
00048 //  Don't need to document the API specifier
00049 #if ! defined( DOXYGEN_IGNORE ) && defined(_WIN32)
00050 # ifdef WRLLOADER_EXPORTS
00051 # define WRLLOADER_API __declspec(dllexport)
00052 # else
00053 # define WRLLOADER_API __declspec(dllimport)
00054 # endif
00055 #else
00056 # define WRLLOADER_API
00057 #endif
00058
00059 #if defined(LINUX)
00060 void lib_init() __attribute__ ((constructor));   // will be called before dlopen() returns
00061 #endif
00062
00064
00068 #if defined(LINUX)
00069 extern "C"
00070 {
00071 #endif
00072 WRLLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00073
00075
00080 WRLLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00081 #if defined(LINUX)
00082 }
00083 #endif
00084
00085 class WRLLoader : public nvsg::SceneLoader
00086 {
00087   public :
00088     //  Default constructor/destructor.
00089     WRLLoader();
00090     ~WRLLoader();
00091
00092   public :
00094
00095     void deleteThis( void );
00096
00098
00103     const nvsg::Scene * load( const std::string& filename
00104                             , const std::vector<std::string> &searchPaths
00105                             , const nvsg::ViewState *& viewState
00107                             );
00108
00109   private :
00110     void                            calculateNormals( vrml::IndexedFaceSet * pIndexedFaceSet,
00111                                                       const nvsg::IndexSet &triVerts, const nvsg::IndexSet &triFaces,
00112                                                       const nvsg::IndexSet &quadVerts, const nvsg::IndexSet &quadFaces );
00113     template<typename T>
00114       void                          combine( vrml::MFFloat &combinedKey, vrml::MFFloat &key, std::vector<T> &value );
00115     void                            determineTexGen( vrml::ElevationGrid * pElevationGrid, const nvsg::StateSet *pStateSet );
00116     void                            determineTexGen( vrml::IndexedFaceSet * pIndexedFaceSet, const nvsg::StateSet *pStateSet );
00117     template<typename VType>
00118       void                          eraseIndex( size_t f, size_t i, size_t count, bool perVertex, vrml::MFInt32 &index,
00119                                                 VType &vec );
00120     template<typename VType>
00121       void                          filterZeroIntervals( vrml::MFFloat &key, std::vector<VType> &value );
00122     vrml::SFNode                    findNode( const vrml::SFNode currentNode, std::string name );
00123     size_t                          getKeyCount( vrml::MFFloat &key );
00124     void                            getKeyRange( vrml::MFFloat &key );
00125     bool                            getNextLine( void );
00126     std::string                   & getNextToken( void );
00127     vrml::SFNode                    getNode( const std::string &nodeName, std::string &token );
00128     void                            ignoreBlock( const std::string &open, const std::string &close, std::string &token );
00129     const nvsg::Scene             * import( const std::string &filename );
00130     const nvsg::StateSet          * interpretAppearance( vrml::Appearance *pAppearance );
00131     void                            interpretChildren( vrml::MFNode &children, nvsg::Group *pNVSGGroup );
00132     void                            interpretBackground( const vrml::Background *pBackground );
00133     const nvsg::Billboard         * interpretBillboard( vrml::Billboard *pVRMLBillboard );
00134     void                            interpretBox( vrml::Box *pBox, std::vector<const nvsg::Drawable*> &drawables, bool textured = false );
00135     const nvsg::DirectedLight     * interpretDirectionalLight( vrml::DirectionalLight *pDirectionalLight );
00136     void                            interpretElevationGrid( vrml::ElevationGrid * pElevationGrid,
00137                                                             std::vector<const nvsg::Drawable*> &drawables );
00138     void                            interpretGeometry( vrml::Geometry *pGeometry,
00139                                                        std::vector<const nvsg::Drawable*> &drawables, bool textured = false );
00140     const nvsg::Group             * interpretGroup( vrml::Group *pGroup );
00141     const nvsg::TextureAttribute  * interpretImageTexture( vrml::ImageTexture *pImageTexture );
00142     void                            interpretIndexedFaceSet( vrml::IndexedFaceSet *pIndexedFaceSet,
00143                                                              std::vector<const nvsg::Drawable*> &drawables );
00144     void                            interpretIndexedLineSet( vrml::IndexedLineSet *pIndexedLineSet,
00145                                                              std::vector<const nvsg::Drawable*> &drawables );
00146     const nvsg::Node              * interpretInline( vrml::Inline * pInline );
00147     const nvsg::LOD               * interpretLOD( vrml::LOD *pVRMLLOD );
00148     const nvsg::Material          * interpretMaterial( vrml::Material * pVRMLMaterial );
00149     void                            interpretOrientationInterpolator( vrml::OrientationInterpolator *pOI );
00150     nvsg::TextureAttribute        * interpretPixelTexture( const vrml::PixelTexture *pPixelTexture );
00151     const nvsg::PointLight        * interpretPointLight( vrml::PointLight *pVRMLPointLight );
00152     void                            interpretPointSet( vrml::PointSet *pPointSet
00153                                                      , std::vector<const nvsg::Drawable*> &drawables );
00154     nvmath::Vec3f                   interpretSFColor( const vrml::SFColor &c );
00155     const nvsg::Object            * interpretSFNode( const vrml::SFNode n );
00156     nvmath::Quatf                   interpretSFRotation( const vrml::SFRotation &r );
00157     const nvsg::GeoNode           * interpretShape( vrml::Shape *pShape );
00158     const nvsg::SpotLight         * interpretSpotLight( vrml::SpotLight *pVRMLSpotLight );
00159     const nvsg::Switch            * interpretSwitch( vrml::Switch *pVRMLSwitch );
00160     const nvsg::TextureAttribute  * interpretTexture( vrml::Texture *pTexture );
00161     void                            interpretTextureTransform( const vrml::TextureTransform *pTextureTransform,
00162                                                                const nvsg::TextureAttribute *pTextureAttribute );
00163     const nvsg::Transform         * interpretTransform( vrml::Transform *pVRMLTransform );
00164     bool                            interpretURL( const vrml::MFString &url, std::string &fileName );
00165     void                            interpretVertexAttributeSet( vrml::IndexedFaceSet *pIndexedFaceSet,
00166                                                                  const nvsg::VertexAttributeSet *pVertextAttributeSet,
00167                                                                  const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> *pAnimation,
00168                                                                  size_t vpf, size_t faceCount,
00169                                                                  nvsg::IndexSet startIndices, nvsg::IndexSet faceIndices );
00170     nvsg::Object                  * interpretViewpoint( const vrml::Viewpoint *pViewpoint );
00171     void                            interpretVRMLTree( void );
00172     bool                            isValidScaling( const vrml::PositionInterpolator *pPositionInterpolator ) const;
00173     bool                            isValidScaling( const vrml::SFVec3f &sfVec3f ) const;
00174     void                            makeCompatible( vrml::CoordinateInterpolator *points, size_t ps,
00175                                                     vrml::NormalInterpolator *normals, size_t ns );
00176     vrml::MFFloat                 * makeCompatible( vrml::PositionInterpolator *center,
00177                                                     vrml::OrientationInterpolator *rotation,
00178                                                     vrml::PositionInterpolator *scale,
00179                                                     vrml::PositionInterpolator *translation );
00180     bool                            onIncompatibleValues( int value0, int value1, const std::string &node,
00181                                                           const std::string &field0, const std::string &field1 ) const;
00182     template<typename T>
00183       bool                          onInvalidValue( T value, const std::string &node, const std::string &field ) const;
00184     bool                            onEmptyToken( const std::string &tokenType, const std::string &token ) const;
00185     bool                            onFileNotFound( const vrml::SFString &url ) const;
00186     bool                            onFilesNotFound( bool found, const vrml::MFString &url ) const;
00187     void                            onUnexpectedEndOfFile( bool error ) const;
00188     void                            onUnexpectedToken( const std::string &expected, const std::string &token ) const;
00189     void                            onUnknownToken( const std::string &tokenType, const std::string &token ) const;
00190     bool                            onUndefinedToken( const std::string &tokenType, const std::string &token ) const;
00191     bool                            onUnsupportedToken( const std::string &tokenType, const std::string &token ) const;
00192     vrml::Anchor                  * readAnchor( const std::string &nodeName );
00193     vrml::Appearance              * readAppearance( const std::string &nodeName );
00194     vrml::AudioClip               * readAudioClip( const std::string &nodeName );
00195     vrml::Background              * readBackground( const std::string &nodeName );
00196     vrml::Billboard               * readBillboard( const std::string &nodeName );
00197     vrml::Box                     * readBox( const std::string &nodeName );
00198     vrml::Collision               * readCollision( const std::string &nodeName );
00199     vrml::Color                   * readColor( const std::string &nodeName );
00200     vrml::ColorInterpolator       * readColorInterpolator( const std::string &nodeName );
00201     vrml::Cone                    * readCone( const std::string &nodeName );
00202     vrml::Coordinate              * readCoordinate( const std::string &nodeName );
00203     vrml::CoordinateInterpolator  * readCoordinateInterpolator( const std::string &nodeName );
00204     vrml::Cylinder                * readCylinder( const std::string &nodeName );
00205     vrml::CylinderSensor          * readCylinderSensor( const std::string &nodeName );
00206     vrml::DirectionalLight        * readDirectionalLight( const std::string &nodeName );
00207     vrml::ElevationGrid           * readElevationGrid( const std::string &nodeName );
00208     void                            readEXTERNPROTO( void );
00209     vrml::Extrusion               * readExtrusion( const std::string &nodeName );
00210     vrml::Fog                     * readFog( const std::string &nodeName );
00211     vrml::FontStyle               * readFontStyle( const std::string &nodeName );
00212     vrml::Group                   * readGroup( const std::string &nodeName );
00213     vrml::ImageTexture            * readImageTexture( const std::string &nodeName );
00214     void                            readIndex( std::vector<vrml::SFInt32> &mf );
00215     vrml::IndexedFaceSet          * readIndexedFaceSet( const std::string &nodeName );
00216     vrml::IndexedLineSet          * readIndexedLineSet( const std::string &nodeName );
00217     vrml::Inline                  * readInline( const std::string &nodeName );
00218     vrml::LOD                     * readLOD( const std::string &nodeName );
00219     vrml::Material                * readMaterial( const std::string &nodeName );
00220     void                            readMFNode( vrml::Group * fatherNode );
00221     template<typename SFType>
00222       void                          readMFType( std::vector<SFType> &mf, void (WRLLoader::*readSFType)( SFType &sf, std::string &token ) );
00223     vrml::MovieTexture            * readMovieTexture( const std::string &nodeName );
00224     vrml::NavigationInfo          * readNavigationInfo( const std::string &nodeName );
00225     vrml::Normal                  * readNormal( const std::string &nodeName );
00226     vrml::NormalInterpolator      * readNormalInterpolator( const std::string &nodeName );
00227     vrml::OrientationInterpolator * readOrientationInterpolator( const std::string &nodeName );
00228     vrml::PixelTexture            * readPixelTexture( const std::string &nodeName );
00229     vrml::PlaneSensor             * readPlaneSensor( const std::string &nodeName );
00230     vrml::PointLight              * readPointLight( const std::string &nodeName );
00231     vrml::PointSet                * readPointSet( const std::string &nodeName );
00232     vrml::PositionInterpolator    * readPositionInterpolator( const std::string &nodeName );
00233     void                            readPROTO( void );
00234     vrml::ProximitySensor         * readProximitySensor( const std::string &nodeName );
00235     void                            readROUTE( const vrml::SFNode currentNode );
00236     vrml::ScalarInterpolator      * readScalarInterpolator( const std::string &nodeName );
00237     vrml::Script                  * readScript( const std::string &nodeName );
00238     void                            readSFBool( vrml::SFBool &b );
00239     void                            readSFColor( vrml::SFColor &c, std::string &token );
00240     void                            readSFFloat( vrml::SFFloat &f, std::string &token );
00241     void                            readSFImage( vrml::SFImage &i );
00242     void                            readSFInt8( vrml::SFInt8 &i );
00243     void                            readSFInt32( vrml::SFInt32 &i, std::string &token );
00244     void                            readSFNode( const vrml::SFNode fatherNode, vrml::SFNode &n, std::string &token );
00245     void                            readSFRotation( vrml::SFRotation &r, std::string &token );
00246     void                            readSFString( vrml::SFString &s, std::string &token );
00247     void                            readSFTime( vrml::SFTime &t );
00248     void                            readSFVec2f( vrml::SFVec2f &v, std::string &token );
00249     void                            readSFVec3f( vrml::SFVec3f &v, std::string &token );
00250     vrml::Shape                   * readShape( const std::string &nodeName );
00251     vrml::Sound                   * readSound( const std::string &nodeName );
00252     vrml::Sphere                  * readSphere( const std::string &nodeName );
00253     vrml::SphereSensor            * readSphereSensor( const std::string &nodeName );
00254     vrml::SpotLight               * readSpotLight( const std::string &nodeName );
00255     void                            readStatements( void );
00256     vrml::Switch                  * readSwitch( const std::string &nodeName );
00257     vrml::Text                    * readText( const std::string &nodeName );
00258     vrml::TextureCoordinate       * readTextureCoordinate( const std::string &nodeName );
00259     vrml::TextureTransform        * readTextureTransform( const std::string &nodeName );
00260     vrml::TimeSensor              * readTimeSensor( const std::string &nodeName );
00261     vrml::TouchSensor             * readTouchSensor( const std::string &nodeName );
00262     vrml::Transform               * readTransform( const std::string &nodeName );
00263     vrml::Viewpoint               * readViewpoint( const std::string &nodeName );
00264     vrml::VisibilitySensor        * readVisibilitySensor( const std::string &nodeName );
00265     vrml::WorldInfo               * readWorldInfo( const std::string &nodeName );
00266     void                            setAnimationData( const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> *pAnimation,
00267                                                       vrml::Coordinate *pCoordinate );
00268     void                            setAnimationData( const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> *pAnimation,
00269                                                       vrml::Coordinate *pCoordinate, vrml::MFInt32 coordIndex,
00270                                                       size_t faceCount, size_t verticesPerFace, nvsg::IndexSet indices );
00271     void                            setNextToken( void );
00272     bool                            testWRLVersion( void );
00273
00274   private :
00275     std::string                           m_currentString;
00276     std::string                           m_currentToken;
00277     std::map<std::string,vrml::SFNode>    m_defNodes;
00278     bool                                  m_eof;
00279     FILE                                * m_fh;
00280     std::vector<vrml::SFNode>             m_inlines;
00281     vrml::SFFloat                         m_keyMin;
00282     vrml::SFFloat                         m_keyMax;
00283     vrml::SFFloat                         m_keyStep;
00284     size_t                                m_keyFrames;
00285     char                                * m_line;
00286     size_t                                m_lineLength;
00287     size_t                                m_lineNumber;
00288     std::string::size_type                m_nextTokenEnd;
00289     std::string::size_type                m_nextTokenStart;
00290     std::vector<vrml::SFNode>             m_openNodes;
00291     std::set<std::string>                 m_PROTONames;
00292     const nvsg::Group                   * m_rootNode;
00293     const nvsg::Scene                   * m_scene;
00294     std::vector<std::string>              m_searchPaths;
00295     vrml::Group                         * m_topLevelGroup;
00296     bool                                  m_strict;
00297     std::string                           m_ungetToken;
00298 };
00299
00300 inline void WRLLoader::deleteThis( void )
00301 {
00302   delete this;
00303 }
00304
00305 inline  nvmath::Vec3f WRLLoader::interpretSFColor( const vrml::SFColor &c )
00306 {
00307   return( * (nvmath::Vec3f *) &c );
00308 }
Generated on Fri Aug 4 08:33:11 2006 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 Fri Aug 4 08:36:28 2006 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::Traverser
00020 {
00021   public:
00023     WRLLoadTraverser();
00024
00026     virtual ~WRLLoadTraverser(void);
00027
00028   protected:
00030
00032     virtual void  doApply( const nvsg::Scene *pScene );
00033
00035
00037     virtual void  handleAnimatedTransform( const nvsg::AnimatedTransform * p );
00038
00040
00042     virtual void  handleBillboard( const nvsg::Billboard *p );
00043
00045
00047     virtual void  handleGroup( const nvsg::Group *p );
00048
00050
00052     virtual void  handleTransform( const nvsg::Transform *p );
00053
00054   private:
00055     void processGroup( const nvsg::Group * p );
00056     void transformLightSource( const nvmath::Trafo &trafo, const nvsg::LightSource * lightSource );
00057
00058   private:
00059     std::vector<const nvsg::LightSource *> m_lights;
00060 };
Generated on Fri Aug 4 08:33:11 2006 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
AnalyzeResult | Base class of the analyzing results determined with the AnalyzeTraverser
AnalyzeTraverser | Traverser that analyzes a tree and reports about potential deficiencies
AnimatedQuads | Class representing an animated Quads
AnimatedTransform | Class representing an animated Transform
AnimatedTriangles | Class representing an animated Triangles
Animation | Class defining the common interface of an animation
AnimationManipulator | This Manipulator controls the camera animation
AppTraverser | AppTraverser Class
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
Bitmap | A Map with one bit per pixel
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
BSplineFilter | ScaleFilter functor providing BSpline filter functionality
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
CgFxEffect | Abstracts a render effect to be applied to a specific geometry
Chunk | Chunk of memory for our low level memory managment of fixed size objects
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
EmptyResult | AnalyzeResult indicating an empty object
EquivalenceResult | AnalyzeResult indicating equivalent objects
Face | Simple helper class for Lines, Quads, and Triangles
FaceAttribute | PrimitiveAttribute specific for Drawables with faces, like Triangles or QuadStrips
FixedAllocator | Manages allocation requests for objects of a certain size only
FlightCameraManipulator | Simulate flight like camera-mouse interaction
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 | Class to hold a set of geometries
GeoNodeCombineTraverser | Traverser that combines multiple GeoNodes under one Group to a single one
GeoNodeUnifyTraverser | Optimizing Traverser that unifies GeoNodes
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
GLTraverser | RenderTraverser using OpenGL
GLWinRenderArea | RenderArea class for MS Windows OpenGL
Group | Provides grouping of Node objects
GroupEliminateTraverser | Traverser that eliminates unneccessary Groups
HighlightBox | A HighlightObject that realizes a bounding box around a Drawable
HighlightEdges | A HighlightObject that realizes a wireframe drawing of the highlighted PrimitiveSet
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
Incarnation | This class abstracts an incarnation count
IndependentPrimitiveSet | Abstract base class for PrimitiveSet objects with independent primitives
indexSet_t | The indexSet_t structure specifies how an index set is stored in a .NBF file
InterpolatedAnimation | Abstract base class for an interpolated Animation of type T
Intersection | Intersection class
ISWMRSync | Single write, multiple read synchronization interface
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
LightSource | Abstract base class for all light sources
LinearInterpolatedAnimation | An InterpolatedAnimation 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
Lockable | The Lockable class allows to add the SWMRSync feature to a non SWMRSync derived class
LOD | Distance-based level of detail class
LODCombineTraverser | Traverser that combines LODS with the same ranges under one Group or Transform to a single one
LODEliminateTraverser | Traverser that eliminates unneccessary LODs
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
Mat33f | Two dimensional matrix of three times three floats
Mat44f | Two dimensional matrix of four times four floats
Material | StateAttribute that describes material properties
Matnnf | Template for two dimensional matrices of floats
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
ModelViewTraverser | Traverser that can handle the model view transform stack
MouseInput | Mouse input helper class to store mouse events
NBFAnimatedIndependents | The NBFAnimatedIndependents structure represents animated independent primitives
NBFAnimatedTransform | The NBFAnimatedTransform structure represents an animated transform group node
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
NBFFramedAnimation | The NBFFramedAnimation structure represents a framed animation
NBFFramedTrafoAnimation | The NBFFramedTrafoAnimation structure represents a framed animation that will be applied to trafo_t objects
NBFFramedVNVectorAnimation | The NBFFramedVNVectorAnimation structure represents a framed animation that will be applied to VNVector 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
NBFInterpolatedAnimation | The NBFInterpolatedAnimation structure represents a interpolated animation
NBFInterpolatedTrafoAnimation | The NBFInterpolatedTrafoAnimation structure represents a interpolated animation that will be applied to trafo_t objects
NBFInterpolatedVNVectorAnimation | The NBFInterpolatedVNVectorAnimation structure represents a interpolated animation that will be applied to VNVector objects
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
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
NBFVertexAttributeSet | The NBFVertexAttributeSet structure represents a set of vertex attributes
NBFViewState | The NBFViewState represents an optional view state used to render the scene
NBFVNVectorAnimation | The NBFVNVectorAnimation represents an animation that will be applied to VNVector objects
Node | Serves as base class for all tree nodes
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
Object | Serves as base class for all traversable objects
Offset_AutoPtr | An auxiliary helper template class which serves for exception save mapping and unmapping of file offsets
OptimizeTraverser | Base for Traversers that perform some optimizations on a scene
ParallelCamera | Class describing a parallel (non-perspective) Camera
Path | Class that represents a path through the tree
PerspectiveCamera | Class describing a perspective Camera
Plane3f | Plane class
plane_t | The plane_t structure specifies how a pair of a bool and a Plane3f is stored in a .NBF file
PlugIn | Plug-in base class
PlugInCallback | PlugInCallback base class
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
PointAttribute | PrimitiveAttribute specific for Points
PointerReference | Provides reference counting for pointers
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
PrimitiveSetCombineTraverser | Optimizing Traverser that combines PrimitiveSets under one GeoNode
PrimitiveSetUnifyTraverser | Optimzing Traverser that unifies PrimitiveSets
ProblemInfo | Class that holds the problem information
QuadMeshes | MeshedPrimitiveSet for quad meshes
Quads | IndependentPrimitiveSet for quads
QuadStrips | StrippedPrimitiveSet for quad strips
Quatf | 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
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
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
ShortStrippedResult | AnalyzeResult indicating a StrippedPrimitiveSet with very short strips
SingleChildResult | AnalyzeResult indicating a Group with a single child
Singleton | A Singleton framework
Skin | Internal helper class for SkinnedTriangles
skin_t | The skin_t structure specifies how a skin is stored in a .NBF file
SkinnedTriangles | Class representing a skinned Triangles
SmoothTraverser | Traverser that can smooth some drawables
Sphere3f | Sphere class
SpotLight | LightSource representing a spot light
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
StateSetUnifyTraverser | Traverser that unifies identical StateSets
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
Switch | Switch node
SwitchToGroupTraverser | Traverser that replaces Switch objects by Group objects holding the active children only
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
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 transfrmation is stored in a .NBF file
Transform | Transform node
TransformCombineTraverser | Traverser that combines identical Transforms
TransformManipulator | Base class for all kinds of transform manipulators
TransformStack | Utility class to hold a stack of concatenated transformation matrices
Traverser | Base class providing an interface for read-write traversing of a given scene graph
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
UPIID | Unique Plug Interface ID
UPITID | Unique Plug Interface Type ID
VariantIterator | Helper class used for iterating the StateVariant objects in a StateSet
Vec2f | Vector class with 2 float components
Vec3f | Vector class with 3 float components
Vec4f | Vector class with 4 float components
Vecnf | Template class for one dimensional vectors of floats
VertexAttributeSet | Class to hold one set of vertex attributes
VertexAttributeSetUnifyTraverser | Optimizing Traverser that unifies VertexAttributeSets
VertexUnifyTraverser | Traverser that can unifies vertices
ViewState | The ViewState class encapsulates the view-specific states
VNVector | A helper class for use in animation
WalkCameraManipulator | Simulate a walk-through camera-mouse interaction
WRLLoader | A Scene Loader for wrl files
WRLLoadTraverser | Internally used traverser for post-processing a just loaded VRML file
Generated on Fri Aug 4 08:36:29 2006 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 Fri Aug 4 08:40:18 2006 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 Fri Aug 4 08:40:18 2006 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 | 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 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 Fri Aug 4 08:40:08 2006 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]
Allocator() | Allocator |
dealloc(void *p, size_t size) | Allocator | [inline]
~Allocator() | Allocator |
Generated on Fri Aug 4 08:40:08 2006 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.

size_t | 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.

size_t objectCount

The number of objects of this type.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:03 2006 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 Fri Aug 4 08:39:03 2006 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 size_t | 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 (const nvsg::Scene *scene)
Override of the doApply method.

virtual NVSG_API void | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Analyze an nvsg::AnimatedQuads.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Analyze an nvsg::AnimatedTransform.

virtual NVSG_API void | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Analyze an nvsg::AnimatedTriangles.

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 | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *p)
Analyze a nvsg::FramedAnimation of type nvmath::Trafo.

virtual NVSG_API void | handleFramedVNVectorAnimation (const nvsg::FramedAnimation< nvsg::VNVector > *p)
Analyze a nvsg::FramedAnimation of type nvsg::VNVector.

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 | handleLinearInterpolatedVNVectorAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p)
Analyze a nvsg::LinearInterpolatedAnimation of type nvsg::VNVector.

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 | 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, size_t 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.

void | postTraverseGroup (const nvsg::Group *p)
This function will be called from the framework immediately after a Group has been traversed.

bool | preTraverseGroup (const nvsg::Group *p)
This function will be called from the framework immediately before a Group is traversed.

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 );
    size_t numberOfResults = analyzeTraverser->getAnalysis( results );
    for ( size_t 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 size_t 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 ( const nvsg::Scene * scene ) [protected, virtual]

Override of the doApply method.

Parameters:
scene A pointer to the constant Scene 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 Traverser.

virtual NVSG_API void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Analyze an nvsg::AnimatedQuads.

Parameters:
p A pointer to the constant nvsg::AnimatedQuads to analyze.
Remarks:
An nvsg::AnimatedQuads is tested for emptiness (no indices), equivalence with any previously encountered AnimatedQuads, and for a missing nvsg::Animation.
See also:
nvsg::AnimatedQuads, EmptyResult, EquivalenceResult, MissingResult

Reimplemented from Traverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Analyze an nvsg::AnimatedTransform.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Analyze an nvsg::AnimatedTriangles.

Parameters:
p A pointer to the constant nvsg::AnimatedTriangles to analyze.
Remarks:
An nvsg::AnimatedTriangles is tested for emptiness (no indices), equivalence with any previously encountered nvsg::AnimatedTriangles, and for a missing nvsg::Animation.
See also:
nvsg::AnimatedTriangles, EmptyResult, EquivalenceResult, MissingResult

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Analyze a nvsg::Billboard.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleBlendAttribute ( const nvsg::BlendAttribute * p ) [protected, virtual]

Analyze a nvsg::BlendAttribute.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Analyze a nvsg::CgFx.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleDepthAttribute ( const nvsg::DepthAttribute * p ) [protected, virtual]

Analyze a nvsg::DepthAttribute.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleDirectedLight ( const nvsg::DirectedLight * p ) [protected, virtual]

Analyze a nvsg::DirectedLight.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Analyze a nvsg::FaceAttribute.

Parameters:
p A pointer to the constant 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 Traverser.

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 constant 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 Traverser.

virtual NVSG_API void handleFramedVNVectorAnimation ( const nvsg::FramedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Analyze a nvsg::FramedAnimation of type nvsg::VNVector.

Parameters:
p A pointer to the constant nvsg::FramedAnimation of type nvsg::VNVector to analyze.
Remarks:
A nvsg::FramedAnimation of type nvsg::VNVector is tested for emptiness (no frames) and for equivalence with any previously encountered nvsg::FramedAnimation of type nvsg::VNVector.
See also:
nvsg::FramedAnimation, nvsg::VNVector, EmptyResult, EquivalenceResult

Reimplemented from Traverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Analyze a nvsg::GeoNode.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Analyze a nvsg::Group.

Parameters:
p A pointer to the constant 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 Traverser.

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 constant 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 Traverser.

virtual NVSG_API void handleLinearInterpolatedVNVectorAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Analyze a nvsg::LinearInterpolatedAnimation of type nvsg::VNVector.

Parameters:
p A pointer to the constant nvsg::LinearInterpolatedAnimation of type nvsg::VNVector to analyze.
Remarks:
A nvsg::LinearInterpolatedAnimation of type nvsg::VNVector is tested for emptiness (no keys) and for equivalence with any previously encountered nvsg::LinearInterpolatedAnimation of type nvsg::VNVector.
See also:
nvsg::LinearInterpolatedAnimation, nvsg::VNVector, EmptyResult, EquivalenceResult

Reimplemented from Traverser.

virtual NVSG_API void handleLineAttribute ( const nvsg::LineAttribute * p ) [protected, virtual]

Analyze a nvsg::LineAttribute.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Analyze a nvsg::Lines.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Analyze a nvsg::LineStrips.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Analyze a nvsg::LOD.

Parameters:
p A pointer to the constant 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, SingleChildResult

Reimplemented from Traverser.

virtual NVSG_API void handleMaterial ( const nvsg::Material * p ) [protected, virtual]

Analyze a nvsg::Material.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handlePointAttribute ( const nvsg::PointAttribute * p ) [protected, virtual]

Analyze a nvsg::PointAttribute.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handlePointLight ( const nvsg::PointLight * p ) [protected, virtual]

Analyze a nvsg::PointLight.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Analyze a nvsg::Points.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Analyze a nvsg::QuadMeshes.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Analyze a nvsg::Quads.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Analyze a nvsg::QuadStrips.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleShape ( const nvsg::Shape * p ) [protected, virtual]

Analyze a nvsg::Shape.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Analyze a nvsg::SkinnedTriangles.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleSpotLight ( const nvsg::SpotLight * p ) [protected, virtual]

Analyze a nvsg::SpotLight.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Analyze a nvsg::StatePass.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Analyze a nvsg::StateSet.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Analyze a nvsg::StateVariant.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Analyze a nvsg::Switch.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Analyze a nvsg::TextureAttribute.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | size_t | tu
 | ) | [protected, virtual]

Analyze a nvsg::TextureAttributeItem.

Parameters:
p | A pointer to the constant 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 Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Analyze a nvsg::Transform.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Analyze a nvsg::Triangles.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Analyze a nvsg::TriFans.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Analyze a nvsg::TriStrips.

Parameters:
p A pointer to the constant 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 Traverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Analyze a nvsg::VertexAttributeSet.

Parameters:
p A pointer to the constant 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 Traverser.

void postTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

This function will be called from the framework immediately after a Group has been traversed.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately after the Group pointed to by p has been traversed.

Reimplemented from Traverser.

bool preTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

This function will be called from the framework immediately before a Group is traversed.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately before the Group pointed to by p is traversed.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:08 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
AnalyzeTraverser(void) | AnalyzeTraverser |
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | AnalyzeTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getAnalysis(std::vector< AnalyzeResult * > &results) const | AnalyzeTraverser |
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | AnalyzeTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | AnalyzeTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | AnalyzeTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | AnalyzeTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [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]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | AnalyzeTraverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | AnalyzeTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | AnalyzeTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | AnalyzeTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | AnalyzeTraverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *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 *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | AnalyzeTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [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]
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, size_t 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]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | AnalyzeTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | AnalyzeTraverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | AnalyzeTraverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~AnalyzeTraverser(void) | AnalyzeTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:08 2006 for NVSGSDK by NVIDIA


AnimatedQuads Class Reference

Class representing an animated Quads. More...

#include <AnimatedQuads.h>

Inheritance diagram for AnimatedQuads:

[legend]
Collaboration diagram for AnimatedQuads:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API const AnimatedQuads * | clone (void) const
Create a new AnimatedQuads by copying from this.

NVSG_API const Animation<
VNVector > * 		getAnimation (void) const
Get a pointer to the constant Animation.

NVSG_API void | setAnimation (const Animation< VNVector > *animation)
Set the Animation.

NVSG_API void | setAnimationFrame (size_t frame)
Set the current animation frame.

virtual NVSG_API size_t | getNumberOfFrames (void) const
Get the number of animation frames.

NVSG_API AnimatedQuads & | operator= (const AnimatedQuads &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other AnimatedQuads.

Static Public Member Functions

NVSG_API const AnimatedQuads * | create (const Animation< VNVector > *animation=NULL)
Create an AnimatedQuads.

NVSG_API const AnimatedQuads * | createFromBase (const Quads &rhs, const Animation< VNVector > *animation=NULL)
Create an AnimatedQuads by copying from a Quads.

Protected Member Functions

NVSG_API | AnimatedQuads (const Animation< VNVector > *animation)
Protected constructor to prevent explicit creation.

NVSG_API | AnimatedQuads (const Quads &rhs, const Animation< VNVector > *animation)
Protected constructor to prevent explicit creation.

NVSG_API | AnimatedQuads (const AnimatedQuads &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~AnimatedQuads (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation (void) const
Validate the Incarnation.

Detailed Description

Class representing an animated Quads.

Namespace: nvsg
Remarks:
This class is a Quads with animation of a VNVector. That is, the vertices and normals of the Quads can be animated.
See also:
AnimatedTriangles, Quads

Constructor & Destructor Documentation

NVSG_API AnimatedQuads ( const Animation< VNVector > * animation ) [protected]

Protected constructor to prevent explicit creation.

Parameters:
animation Pointer to the constant Animation to use, or NULL
Remarks:
This constructor is never used explicitly, but only inside AnimatedQuads::create.
See also:
Animation, VNVector

NVSG_API AnimatedQuads | ( | const Quads & | rhs,
 |  | const Animation< VNVector > * | animation
 | ) | [protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs | Reference to a constant Quads to use as a base of the new AnimatedQuads
animation | Pointer to the constant Animation to use, or NULL
Remarks:
This constructor is never used explicitly, but only inside AnimatedQuads::createFromBase.
See also:
Animation, Quads, VNVector

NVSG_API AnimatedQuads ( const AnimatedQuads & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to a constant AnimatedQuads to copy from
Remarks:
This constructor is never used explicitly, but only inside AnimatedQuads::create.
See also:
Animation, Quads, VNVector

virtual NVSG_API ~AnimatedQuads ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the AnimatedQuads is decremented to zero. The reference count of the Animation of this AnimatedQuads is then decremented.
See also:
Animation, Quads, addRef, removeRef

Member Function Documentation

NVSG_API const AnimatedQuads* create ( const Animation< VNVector > * animation = NULL ) [static]

Create an AnimatedQuads.

Parameters:
animation Optional pointer to the constant Animation to use; default is NULL
Returns:
A pointer to a constant AnimatedQuads.
Remarks:
If the optional parameter animation is given, its reference count is incremented and it is used as the Animation. Otherwise an empty Animation is created.
See also:
Animation, Quads, VNVector, addRef

NVSG_API const AnimatedQuads* createFromBase | ( | const Quads & | rhs,
 |  | const Animation< VNVector > * | animation = NULL
 | ) | [static]

Create an AnimatedQuads by copying from a Quads.

Parameters:
rhs | Reference to a constant Quads to copy from
animation | Optional pointer to the constant Animation to use; default is NULL
Returns:
A pointer to a constant AnimatedQuads.
Remarks:
All the data from the Quads rhs is used as the base information for the newly created AnimatedQuads. If the optional parameter animation is given, its reference count is incremented and it is used as the Animation. Otherwise an empty Animation is created.
See also:
Animation, Quads, VNVector, addRef

virtual NVSG_API const AnimatedQuads* clone ( void ) const [virtual]

Create a new AnimatedQuads by copying from this.

Returns:
A pointer to a constant AnimatedQuads.
Remarks:
The newly created AnimatedQuads is an exact copy of this.

Reimplemented from Quads.

const Animation< VNVector > * getAnimation ( void ) 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, VNVector

NVSG_API void setAnimation ( const Animation< VNVector > * animation )

Set the Animation.

Parameters:
animation Pointer to the constant Animation to use
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 contain 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, VNVector, invalidateNumberOfFrames, addRef, removeRef

NVSG_API void setAnimationFrame ( size_t frame )

Set the current animation frame.

Parameters:
frame Index of the current frame
Remarks:
The vertices and normals of the animation step frame are used for the current Animation.
Note:
The behaviour is undefined if frame is out of the range of the current Animation.
See also:
Animation, VNVector

virtual NVSG_API size_t getNumberOfFrames ( void ) const [virtual]

Get the number of animation frames.

Returns:
Number of frames in the Animation.

Reimplemented from Drawable.

NVSG_API AnimatedQuads& operator= ( const AnimatedQuads & rhs )

Assignment operator.

Parameters:
rhs Reference to a constant AnimatedQuads to copy from
Returns:
A reference to the assigned AnimatedQuads
Remarks:
The assignment operator first calls the assignment operator of Quads. Then the reference count of the current Animation is decremented, the Animation of rhs is cloned, and its reference count is incremented.
See also:
Animation, Quads, addRef, removeRef

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other AnimatedQuads.

Parameters:
p | Pointer to a constant AnimatedQuads 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 AnimatedQuads p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent Quads, 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 AnimatedQuads nor derived from one.
See also:
Animation, Object, Quads

Reimplemented from IndependentPrimitiveSet.

virtual NVSG_API void validateIncarnation ( void ) const [protected, 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 the Animation is requested to continue validation down the tree hierarchy. Incarnation

Reimplemented from PrimitiveSet.

The documentation for this class was generated from the following file:
  • AnimatedQuads.h
Generated on Fri Aug 4 08:37:29 2006 for NVSGSDK by NVIDIA


Member List

AnimatedQuads Member List

This is the complete list of members for AnimatedQuads, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
AnimatedQuads(const Animation< VNVector > *animation) | AnimatedQuads | [protected]
AnimatedQuads(const Quads &rhs, const Animation< VNVector > *animation) | AnimatedQuads | [protected]
AnimatedQuads(const AnimatedQuads &rhs) | AnimatedQuads | [protected]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(const Quads *q, size_t tu=0, size_t tg=1, size_t bn=2) | Quads | [related]
clone(void) const | AnimatedQuads | [virtual]
create(const Animation< VNVector > *animation=NULL) | AnimatedQuads | [static]
nvsg::Quads::create() | Quads | [static]
createFromBase(const Quads &rhs, const Animation< VNVector > *animation=NULL) | AnimatedQuads | [static]
nvsg::Quads::createFromBase(const IndependentPrimitiveSet &rhs) | Quads | [static]
nvsg::Quads::createFromBase(const PrimitiveSet &rhs) | Quads | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const Quads *q) | Quads | [related]
getAnimation(void) const | AnimatedQuads | [inline]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFaces() const | Quads | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFaces() const | Quads | [inline]
getNumberOfFrames(void) const | AnimatedQuads | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Quads | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | AnimatedQuads | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const AnimatedQuads &rhs) | AnimatedQuads |
nvsg::Quads::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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
Quads() | Quads | [protected]
Quads(const IndependentPrimitiveSet &rhs) | Quads | [protected]
Quads(const PrimitiveSet &rhs) | Quads | [protected]
Quads(const Quads &rhs) | Quads | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAnimation(const Animation< VNVector > *animation) | AnimatedQuads |
setAnimationFrame(size_t frame) | AnimatedQuads |
setFaces(const Face4 *faces, size_t numFaces) | Quads | [inline]
setFaces(size_t pos, const Face4 *faces, size_t numFaces) | Quads | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | AnimatedQuads | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~AnimatedQuads(void) | AnimatedQuads | [protected, virtual]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~Quads() | Quads | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:29 2006 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

virtual NVSG_API AnimatedTransform * | clone (void) const
Create a new AnimatedTransform by copying from this.

NVSG_API const Animation<
nvmath::Trafo > * 		getAnimation (void) const
Get a pointer to the constant Animation.

NVSG_API void | setAnimation (const Animation< nvmath::Trafo > *animation)
Set the Animation.

NVSG_API void | setAnimationFrame (size_t frame)
Set the current animation frame.

virtual NVSG_API void | setTrafo (const nvmath::Trafo &trafo)
Set the nvmath::Trafo to use.

virtual NVSG_API size_t | getNumberOfFrames (void) const
Get the number of animation frames.

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.

Static Public Member Functions

NVSG_API const AnimatedTransform * | create (const Animation< nvmath::Trafo > *animation=NULL)
Create an AnimatedTransform.

NVSG_API const AnimatedTransform * | createFromBase (const Transform &rhs, const Animation< nvmath::Trafo > *animation=NULL)
Create an AnimatedTransform by copying from a Transform.

Protected Member Functions

NVSG_API | AnimatedTransform (const Animation< nvmath::Trafo > *animation)
Protected constructor to prevent explicit creation.

NVSG_API | AnimatedTransform (const Transform &rhs, const Animation< nvmath::Trafo > *animation)
Protected constructor to prevent explicit creation.

NVSG_API | AnimatedTransform (const AnimatedTransform &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~AnimatedTransform (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation (void) const
Validate the Incarnation.

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 ( const Animation< nvmath::Trafo > * animation ) [protected]

Protected constructor to prevent explicit creation.

Parameters:
animation Pointer to the constant Animation to use, or NULL
Remarks:
This constructor is never used explicitly, but only inside AnimatedTransform::create.
See also:
Animation, nvmath::Trafo

NVSG_API AnimatedTransform | ( | const Transform & | rhs,
 |  | const Animation< nvmath::Trafo > * | animation
 | ) | [protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs | Reference to a constant Transform to use as a base of the new AnimatedTransform
animation | Pointer to the constant Animation to use, or NULL
Remarks:
This constructor is never used explicitly, but only inside AnimatedTransform::createFromBase.
See also:
Animation, nvmath::Trafo, Transform

NVSG_API AnimatedTransform ( const AnimatedTransform & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to a constant AnimatedTransform to copy from
Remarks:
This constructor is never used explicitly, but only inside AnimatedTransform::create.
See also:
Animation, nvmath::Trafo, Transform

virtual NVSG_API ~AnimatedTransform ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the AnimatedTransform is decremented to zero. The reference count of the Animation of this AnimatedQuads is then decremented.
See also:
Animation, Transform, addRef, removeRef

Member Function Documentation

NVSG_API const AnimatedTransform* create ( const Animation< nvmath::Trafo > * animation = NULL ) [static]

Create an AnimatedTransform.

Parameters:
animation Optional pointer to the constant Animation to use; default is NULL
Returns:
A pointer to a constant AnimatedTransform
Remarks:
If the optional parameter animation is given, its reference count is incremented and it is used as the Animation. Otherwise, an empty Animation is created.
See also:
Animation, nvmath::Trafo, Transform, addRef

NVSG_API const AnimatedTransform* createFromBase | ( | const Transform & | rhs,
 |  | const Animation< nvmath::Trafo > * | animation = NULL
 | ) | [static]

Create an AnimatedTransform by copying from a Transform.

Parameters:
rhs | Reference to a constant Transform to copy from
animation | Optional pointer to the constant Animation to use; default is NULL
Returns:
A pointer to a constant AnimatedTransform.
Remarks:
All the data from the Transform rhs is used as the base information for the newly created AnimatedTransform. If the optional parameter animation is given, its reference count is incremented and it is used as the Animation. Otherwise, an empty Animation is created.
See also:
Animation, nvmath::Trafo, Transform, addRef

virtual NVSG_API AnimatedTransform* clone ( void ) const [virtual]

Create a new AnimatedTransform by copying from this.

Returns:
A pointer to a constant AnimatedTransform
Remarks:
The newly created AnimatedTransform is an exact copy of this.

Reimplemented from Transform.

const Animation< nvmath::Trafo > * getAnimation ( void ) 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 ( const Animation< nvmath::Trafo > * 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, invalidateNumberOfFrames, addRef, removeRef

NVSG_API void setAnimationFrame ( size_t frame )

Set the current animation frame.

Parameters:
frame Index of the current frame
Remarks:
The nvmath::Trafo of the animation step frame is used as the current transformation.
Note:
The behavior is undefined if frame is out of the range of the current Animation.
See also:
Animation, nvmath::Trafo

virtual NVSG_API void setTrafo ( const nvmath::Trafo & trafo ) [virtual]

Set the nvmath::Trafo to use.

Parameters:
trafo Reference to the constant nvmath::Trafo to use
Remarks:
In addition to setting the nvmath::Trafo by calling Transform::setTrafo, the current frame is invalidated.
See also:
nvmath::Trafo, Transform

Reimplemented from Transform.

virtual NVSG_API size_t getNumberOfFrames ( void ) const [virtual]

Get the number of animation frames.

Returns:
Number of frames in the 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 void validateIncarnation ( void ) const [protected, 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.

The documentation for this class was generated from the following file:
  • AnimatedTransform.h
Generated on Fri Aug 4 08:37:31 2006 for NVSGSDK by NVIDIA


Member List

AnimatedTransform Member List

This is the complete list of members for AnimatedTransform, including all inherited members.
activateClipPlane(size_t index) | Group | [inline]
addChild(const Node *child, size_t position=0xFFFFFFFF) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
AnimatedTransform(const Animation< nvmath::Trafo > *animation) | AnimatedTransform | [protected]
AnimatedTransform(const Transform &rhs, const Animation< nvmath::Trafo > *animation) | AnimatedTransform | [protected]
AnimatedTransform(const AnimatedTransform &rhs) | AnimatedTransform | [protected]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere(void) const | Transform | [protected, virtual]
clone(void) const | AnimatedTransform | [virtual]
containsCgFx() const | Group | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Group | [virtual]
containsTransparentGeometry() const | Node |
create(const Animation< nvmath::Trafo > *animation=NULL) | AnimatedTransform | [static]
nvsg::Transform::create(void) | Transform | [static]
createFromBase(const Transform &rhs, const Animation< nvmath::Trafo > *animation=NULL) | AnimatedTransform | [static]
nvsg::Transform::createFromBase(const Group &rhs) | Transform | [static]
nvsg::Group::createFromBase(const Node &rhs) | Group | [static]
deactivateClipPlane(size_t index) | Group | [inline]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnimation(void) const | AnimatedTransform | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getChild(size_t position) const | Group | [inline]
getChildPositions(const Node *node, std::vector< size_t > &positions) const | Group |
getClipPlane(size_t index) const | Group | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfFrames(void) const | AnimatedTransform | [virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getTrafo(void) const | Transform | [inline]
Group() | Group | [protected]
Group(const Node &rhs) | Group | [explicit, protected]
Group(const Group &rhs) | Group | [protected]
hasChild(const Node *node) const | Group |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const Node *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Group | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Group | [virtual]
invalidateNumberOfFrames() const | Group | [virtual]
invalidateTransparencyContainment() | Node |
isClipPlaneActive(size_t index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | AnimatedTransform | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
postAddChild(size_t position) | Group | [protected, virtual]
postRemoveChild(size_t position) | Group | [protected, virtual]
preAddChild(size_t position) | Group | [protected, virtual]
preRemoveChild(size_t position) | Group | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeChild(const Node *child) | Group |
removeChild(size_t position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceChild(const Node *newChild, const Node *oldChild) | Group |
replaceChild(const Node *newChild, size_t position) | Group |
setAnimation(const Animation< nvmath::Trafo > *animation) | AnimatedTransform |
setAnimationFrame(size_t frame) | AnimatedTransform |
setAnnotation(const std::string &anno) | Node |
setClipPlane(size_t 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 | [virtual]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
Transform(void) | Transform | [protected]
Transform(const Group &rhs) | Transform | [protected]
Transform(const Transform &rhs) | Transform | [protected]
validateIncarnation(void) const | AnimatedTransform | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~AnimatedTransform(void) | AnimatedTransform | [protected, virtual]
~Group() | Group | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Transform(void) | Transform | [protected, virtual]
Generated on Fri Aug 4 08:37:31 2006 for NVSGSDK by NVIDIA


AnimatedTriangles Class Reference

Class representing an animated Triangles. More...

#include <AnimatedTriangles.h>

Inheritance diagram for AnimatedTriangles:

[legend]
Collaboration diagram for AnimatedTriangles:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API const AnimatedTriangles * | clone (void) const
Create a new AnimatedTriangles by copying from this.

NVSG_API const Animation<
VNVector > * 		getAnimation (void) const
Get a pointer to the constant Animation.

NVSG_API void | setAnimation (const Animation< VNVector > *animation)
Set the Animation.

NVSG_API void | setAnimationFrame (size_t frame)
Set the current animation frame.

virtual NVSG_API size_t | getNumberOfFrames (void) const
Get the number of animation frames.

NVSG_API AnimatedTriangles & | operator= (const AnimatedTriangles &rhs)
Assignment operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other AnimatedTriangles.

Static Public Member Functions

NVSG_API const AnimatedTriangles * | create (const Animation< VNVector > *animation=NULL)
Create an AnimatedTriangles.

NVSG_API const AnimatedTriangles * | createFromBase (const Triangles &rhs, const Animation< VNVector > *animation=NULL)
Create an AnimatedTriangles by copying from a Triangles.

Protected Member Functions

NVSG_API | AnimatedTriangles (const Animation< VNVector > *animation)
Protected constructor to prevent explicit creation.

NVSG_API | AnimatedTriangles (const Triangles &rhs, const Animation< VNVector > *animation)
Protected constructor to prevent explicit creation.

NVSG_API | AnimatedTriangles (const AnimatedTriangles &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~AnimatedTriangles (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation (void) const
Validate the Incarnation.

Detailed Description

Class representing an animated Triangles.

Namespace: nvsg
Remarks:
This class is a Triangles with an Animation of a VNVector. That is, the vertices and normals of the Triangles can be animated.
See also:
AnimatedQuads, Triangles

Constructor & Destructor Documentation

NVSG_API AnimatedTriangles ( const Animation< VNVector > * animation ) [protected]

Protected constructor to prevent explicit creation.

Parameters:
animation Pointer to the constant Animation to use, or NULL
Remarks:
This constructor is never used explicitly, but only inside AnimatedTriangles::create.
See also:
Animation, VNVector

NVSG_API AnimatedTriangles | ( | const Triangles & | rhs,
 |  | const Animation< VNVector > * | animation
 | ) | [protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs | Reference to a constant Triangles to use as a base of the new AnimatedTriangles
animation | Pointer to the constant Animation to use, or NULL
Remarks:
This constructor is never used explicitly, but only inside AnimatedTriangles::createFromBase.
See also:
Animation, Triangles, VNVector

NVSG_API AnimatedTriangles ( const AnimatedTriangles & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to a constant AnimatedTriangles to copy from
Remarks:
This constructor is never used explicitly, but only inside AnimatedTriangles::create.
See also:
Animation, Triangles, VNVector

virtual NVSG_API ~AnimatedTriangles ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the AnimatedTriangles is decremented to zero. The reference count of the Animation of this AnimatedTriangles is then decremented.
See also:
Animation, Triangles, addRef, removeRef

Member Function Documentation

NVSG_API const AnimatedTriangles* create ( const Animation< VNVector > * animation = NULL ) [static]

Create an AnimatedTriangles.

Parameters:
animation Optional pointer to the constant Animation to use; default is NULL
Returns:
A pointer to a constant AnimatedTriangles.
Remarks:
If the optional parameter animation is given, its reference count is incremented and it is used as the Animation. Otherwise an empty Animation is created.
See also:
Animation, Triangles, VNVector, addRef

NVSG_API const AnimatedTriangles* createFromBase | ( | const Triangles & | rhs,
 |  | const Animation< VNVector > * | animation = NULL
 | ) | [static]

Create an AnimatedTriangles by copying from a Triangles.

Parameters:
rhs | Pointer to the constant Triangles to copy from
animation | Optional pointer to the constant Animation to use; default is NULL
Returns:
A pointer to a constant AnimatedTriangles.
Remarks:
All the data from the Triangles rhs is used as the base information for the newly created AnimatedTriangles. If the optional parameter animation is given, its reference count is incremented and it is used as the Animation. Otherwise, an empty Animation is created.
See also:
Animation, Triangles, VNVector, addRef

virtual NVSG_API const AnimatedTriangles* clone ( void ) const [virtual]

Create a new AnimatedTriangles by copying from this.

Returns:
A pointer to a constant AnimatedTriangles
Remarks:
The newly created AnimatedTriangles is an exact copy of this.

Reimplemented from Triangles.

const Animation< VNVector > * getAnimation ( void ) 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, VNVector

NVSG_API void setAnimation ( const Animation< VNVector > * 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, VNVector, invalidateNumberOfFrames, addRef, removeRef

NVSG_API void setAnimationFrame ( size_t frame )

Set the current animation frame.

Parameters:
frame index of the current frame
Remarks:
The vertices and normals of the animation step frame are used as the vertices and normals.
Note:
The behaviour is undefined if frame is out of the range of the current Animation.
See also:
Animation, VNVector

virtual NVSG_API size_t getNumberOfFrames ( void ) const [virtual]

Get the number of animation frames.

Returns:
Number of frames in the Animation.

Reimplemented from Drawable.

NVSG_API AnimatedTriangles& operator= ( const AnimatedTriangles & rhs )

Assignment operator.

Parameters:
rhs Reference to a constant AnimatedTriangles to copy from
Returns:
A reference to the assigned AnimatedTriangles
Remarks:
The assignment operator first calls the assignment operator of Triangles. Then the reference count of the current Animation is decremented, the Animation of rhs is cloned and its reference count is incremented.
See also:
Animation, Triangles, addRef, removeRef

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other AnimatedTriangles.

Parameters:
p | Pointer to the constant AnimatedTriangles 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 AnimatedTriangles p is equivalent to this, otherwise false.
Remarks:
If p and this are equivalent as Triangles, 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 AnimatedTriangles nor derived from one.
See also:
Animation, Object, Triangles

Reimplemented from IndependentPrimitiveSet.

virtual NVSG_API void validateIncarnation ( void ) const [protected, 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 the Animation is requested to continue validation down the tree hierarchy. Incarnation

Reimplemented from PrimitiveSet.

The documentation for this class was generated from the following file:
  • AnimatedTriangles.h
Generated on Fri Aug 4 08:37:32 2006 for NVSGSDK by NVIDIA


Member List

AnimatedTriangles Member List

This is the complete list of members for AnimatedTriangles, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
AnimatedTriangles(const Animation< VNVector > *animation) | AnimatedTriangles | [protected]
AnimatedTriangles(const Triangles &rhs, const Animation< VNVector > *animation) | AnimatedTriangles | [protected]
AnimatedTriangles(const AnimatedTriangles &rhs) | AnimatedTriangles | [protected]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(const Triangles *t, size_t tu=0, size_t tg=1, size_t bn=2) | Triangles | [related]
clone(void) const | AnimatedTriangles | [virtual]
create(const Animation< VNVector > *animation=NULL) | AnimatedTriangles | [static]
nvsg::Triangles::create() | Triangles | [static]
createFromBase(const Triangles &rhs, const Animation< VNVector > *animation=NULL) | AnimatedTriangles | [static]
nvsg::Triangles::createFromBase(const IndependentPrimitiveSet &rhs) | Triangles | [static]
nvsg::Triangles::createFromBase(const PrimitiveSet &rhs) | Triangles | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const Triangles *q) | Triangles | [related]
getAnimation(void) const | AnimatedTriangles | [inline]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFaces() const | Triangles | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFaces() const | Triangles | [inline]
getNumberOfFrames(void) const | AnimatedTriangles | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Triangles | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | AnimatedTriangles | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const AnimatedTriangles &rhs) | AnimatedTriangles |
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAnimation(const Animation< VNVector > *animation) | AnimatedTriangles |
setAnimationFrame(size_t frame) | AnimatedTriangles |
setFaces(const Face3 *faces, size_t numFaces) | Triangles | [inline]
setFaces(size_t pos, const Face3 *faces, size_t numFaces) | Triangles | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
Triangles() | Triangles | [protected]
Triangles(const IndependentPrimitiveSet &rhs) | Triangles | [protected]
Triangles(const PrimitiveSet &rhs) | Triangles | [protected]
Triangles(const Triangles &rhs) | Triangles | [protected]
validateIncarnation(void) const | AnimatedTriangles | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~AnimatedTriangles(void) | AnimatedTriangles | [protected, virtual]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Triangles() | Triangles | [protected, virtual]
Generated on Fri Aug 4 08:37:32 2006 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]
Collaboration diagram for Animation:

[legend]
List of all members.

Public Member Functions

virtual const Animation< T > * | clone (void) const=0
Interface for creating a new Animation by copying from this.

virtual size_t | getNumberOfFrames (void) const=0
Interface for getting the number of animation frames.

virtual const T & | operator[] (size_t i) const=0
Interface for the constant random access operator.

Protected Member Functions

Animation (void)
Protected constructor to prevent explicit creation.

virtual | ~Animation (void)
Protected destructor 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 ( void ) [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

~Animation ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Animation is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

virtual const Animation<T>* clone ( void ) const [pure virtual]

Interface for creating a new Animation by copying from this.

Returns:
A pointer to a constant Animation.
Remarks:
The newly created Animation has to be an exact copy of this.

Implemented in FramedAnimation, LinearInterpolatedAnimation, and FramedAnimation< nvmath::Trafo >.

virtual size_t getNumberOfFrames ( void ) const [pure virtual]

Interface for getting the number of animation frames.

Returns:
Number of frames in the Animation.

Implemented in FramedAnimation, InterpolatedAnimation, FramedAnimation< nvmath::Trafo >, and InterpolatedAnimation< nvmath::Trafo >.

virtual const T& operator[] ( size_t i ) const [pure virtual]

Interface for the constant random access operator.

Parameters:
i Index of frame to access
Returns:
Reference of the constant i th element of the Animation.
Remarks:
Only the constant random access operator is required. But a concrete class based on Animation also might define a non-constant random access operator if appropriate.
Note:
The behavior is undefined if i is out of the range of the Animation.

Implemented in FramedAnimation, LinearInterpolatedAnimation, and FramedAnimation< nvmath::Trafo >.

Animation< T > & operator= ( const Animation< T > & rhs ) [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 Fri Aug 4 08:37:33 2006 for NVSGSDK by NVIDIA


Member List

Animation Member List

This is the complete list of members for Animation, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
Animation(void) | Animation | [protected]
clone(void) const=0 | Animation | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const=0 | Animation | [pure virtual]
getObjectCode() const | Object | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Animation< T > &rhs) | Animation | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
operator[](size_t i) const=0 | Animation | [pure virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Animation(void) | Animation | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:33 2006 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 | setNumberOfFrames (size_t frames)
Set the number of animation frames.

NVSG_API void | setCameraAnimation (const nvsg::Animation< nvmath::Trafo > *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.

NVSG_API void | firstFrame ()
Jump to the first animation frame.

NVSG_API void | lastFrame ()
Jump to the last animation frame.

NVSG_API void | gotoFrame (size_t frame)
Jump to the specified animation frame.

Protected Attributes

const nvsg::Animation< nvmath::Trafo > * | m_cameraAnimation
Camera animation information.

size_t | m_currentFrame
Current animation frame.

size_t | m_numberOfFrames
Maximum number of animation frames.

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, firstFrame, lastFrame, gotoFrame, 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.

void setNumberOfFrames ( size_t frames ) [inline]

Set the number of animation frames.

Parameters:
frames The total number of animation frames.
Remarks:
Set here the total number of animation frames. Even when there is no camera animation set via setCameraAnimation the scene could contain other kinds of animations. So no camera animation is not a hint to set this value to NULL.
Example
  m_pAnimationManip = new AnimationManipulator;
  m_pAnimationManip->setRenderArea(m_pRA);

  // We need to ask the scene for the complete numbers of frames.
  // Do not forget - there could be other animations even when there is no camera animation!
  m_pAnimationManip->setNumberOfFrames(GetDocument()->getScene()->getNumberOfFrames());

  // could be NULL, if there is no camera animation
  m_pAnimationManip->setCameraAnimation(GetDocument()->getScene()->getCameraAnimation());

NVSG_API void setCameraAnimation ( const nvsg::Animation< nvmath::Trafo > * 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.
Example
See sample code: setNumberOfFrames
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, firstFrame, lastFrame, gotoFrame

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, firstFrame, lastFrame, gotoFrame

void firstFrame ( ) [inline]

Jump to the first animation frame.

Remarks:
Simply set the counter to the first frame of the animation.
See also:
nextFrame, previousFrame, lastFrame, gotoFrame

void lastFrame ( ) [inline]

Jump to the last animation frame.

Remarks:
Simply set the counter to the last frame of the animation.
See also:
nextFrame, previousFrame, lastFrame, gotoFrame

void gotoFrame ( size_t frame ) [inline]

Jump to the specified animation frame.

Parameters:
frame Null based index of the animation frame. (0 <= frame < numberOfFrames) The application has to make sure that the frame index is valid. If the parameter is an invalid value, the behavior of this function is not defined.
Remarks:
Simply set the frame index to the specified frame number.
See also:
nextFrame, previousFrame, firstFrame, lastFrame

Member Data Documentation

const nvsg::Animation<nvmath::Trafo>* m_cameraAnimation [protected]

Camera animation information.

size_t m_currentFrame [protected]

Current animation frame.

size_t m_numberOfFrames [protected]

Maximum number of animation frames.

The documentation for this class was generated from the following file:
  • AnimationManipulator.h
Generated on Fri Aug 4 08:39:54 2006 for NVSGSDK by NVIDIA


Member List

AnimationManipulator Member List

This is the complete list of members for AnimationManipulator, including all inherited members.
AnimationManipulator() | AnimationManipulator |
firstFrame() | AnimationManipulator | [inline]
gotoFrame(size_t frame) | AnimationManipulator | [inline]
isActive() | AnimationManipulator | [inline, virtual]
lastFrame() | AnimationManipulator | [inline]
m_cameraAnimation | AnimationManipulator | [protected]
m_currentFrame | AnimationManipulator | [protected]
m_numberOfFrames | AnimationManipulator | [protected]
m_renderArea | Manipulator | [protected]
Manipulator() | Manipulator |
nextFrame() | AnimationManipulator | [inline]
previousFrame() | AnimationManipulator | [inline]
setCameraAnimation(const nvsg::Animation< nvmath::Trafo > *animation) | AnimationManipulator |
setNumberOfFrames(size_t frames) | AnimationManipulator | [inline]
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
updateFrame() | AnimationManipulator | [virtual]
~AnimationManipulator() | AnimationManipulator | [virtual]
~Manipulator() | Manipulator | [virtual]
Generated on Fri Aug 4 08:39:54 2006 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 Member Functions

NVSG_API | AppTraverser ()
Default constructor.

Protected Member Functions

virtual NVSG_API | ~AppTraverser ()
Default destructor.

virtual NVSG_API bool | needsTraversal (void) const
Determines if the AppTraverser really should traverse the tree.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
doApply override

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Routine to handle a GeoNode while traversing the scene graph.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Provide special treatment of an AnimatedTransform node.

virtual NVSG_API void | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Routine to handle a AnimatedQuads object while traversing the scene graph.

virtual NVSG_API void | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Routine to handle a AnimatedTriangles 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 | handleCgFx (const nvsg::CgFx *p)
Routine to handle a CgFx attribute while traversing the scene graph.

virtual NVSG_API void | handleHighlightBox (const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive)
Routine to handle a HighlightBox object while traversing the scene graph.

virtual NVSG_API void | traverseLight (const nvsg::LightSource *p)
This function will be called from the framework when a LightSource node is visited.

Protected Attributes

bool | m_bApplyingCgFx
Flag that signals if a CgFX effect needs to be handled (tangentspace calculation).

size_t | 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 ( void ) 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 ( const nvsg::Scene * scene ) [protected, virtual]

doApply override

Reimplemented from Traverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode while traversing the scene graph.

This routine gets called for each GeoNode object that will be visited while traversing the scene graph. The currently visited GeoNode object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

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 ModelViewTraverser.

virtual NVSG_API void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Routine to handle a AnimatedQuads object while traversing the scene graph.

This routine gets called for each AnimatedQuads object that will be visited while traversing the scene graph. The currently visited AnimatedQuads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Routine to handle a AnimatedTriangles object while traversing the scene graph.

This routine gets called for each AnimatedTriangles object that will be visited while traversing the scene graph. The currently visited AnimatedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Routine to handle a SkinnedTriangles object while traversing the scene graph.

This routine gets called for each SkinnedTriangles object that will be visited while traversing the scene graph. The currently visited SkinnedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Routine to handle a CgFx attribute while traversing the scene graph.

This routine gets called for each CgFx object that will be visited while traversing the scene graph. The currently visited CgFx object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleHighlightBox | ( | const nvsg::HighlightBox * | p,
 |  | const nvsg::PrimitiveSet * | primitive
 | ) | [protected, virtual]

Routine to handle a HighlightBox object while traversing the scene graph.

This routine gets called for each HighlightBox object that will be visited while traversing the scene graph. The currently visited Highlight object is pointed to by p.

Remarks:
A HighlighBox always is attached to its corresponding PrimitiveSet object as a HighlightObject .
Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void traverseLight ( const nvsg::LightSource * p ) [protected, virtual]

This function will be called from the framework when a LightSource node is visited.

remarks Custom traversers can override this function for special tasks that need to be performed when visiting a LightSource node.

Reimplemented from Traverser.

Member Data Documentation

bool m_bApplyingCgFx [protected]

Flag that signals if a CgFX effect needs to be handled (tangentspace calculation).

size_t m_animationFrame [protected]

Current animation frame.

The documentation for this class was generated from the following file:
  • AppTraverser.h
Generated on Fri Aug 4 08:39:09 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
AppTraverser() | AppTraverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | AppTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | AppTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | AppTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | AppTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | ModelViewTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | AppTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | AppTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | AppTraverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | ModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | AppTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | ModelViewTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_animationFrame | AppTraverser | [protected]
m_bApplyingCgFx | AppTraverser | [protected]
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [protected]
needsTraversal(void) const | AppTraverser | [protected, virtual]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | ModelViewTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | ModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setViewState(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | AppTraverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~AppTraverser() | AppTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:09 2006 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 Fri Aug 4 08:38:53 2006 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, 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 Fri Aug 4 08:38:53 2006 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 Member Functions

virtual NVSG_API const Billboard * | clone () const
Create a new Billboard by copying from this.

NVSG_API nvmath::Trafo | getTrafoAxisAligned (const nvmath::Vec3f &viewerPosition) const
Get the current Trafo if the Billboard is not screen aligned.

NVSG_API nvmath::Trafo | getTrafoScreenAligned (const nvmath::Vec3f &viewerPosition, const nvmath::Vec3f &upVector) const
Get the current Trafo if the Billboard is screen aligned.

NVSG_API bool | isScreenAligned () const
Query if the Billboard is to be screen aligned.

NVSG_API void | setScreenAligned (bool on)
Set the Billboard to be screen aligned.

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.

Static Public Member Functions

NVSG_API const Billboard * | create ()
Create a Billboard.

NVSG_API const Billboard * | createFromBase (const Group &rhs)
Create a Billboard by copying from a Group.

Protected Member Functions

NVSG_API | Billboard ()
Protected constructor to prevent explicit creation.

NVSG_API | Billboard (const Group &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | Billboard (const Billboard &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Billboard ()
Protected destructor to prevent explicit creation.

Detailed Description

Class that adds billboard properties to a Group.

Namespace: nvsg
Remarks:
The Billboard is a special transforming Group that performs a rotation around the rotationAxis, such that the contents of the Group is always oriented towards the viewer.
See also:
Group, Transform

Constructor & Destructor Documentation

NVSG_API Billboard ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Billboard::create.

NVSG_API Billboard ( const Group & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant Group to use as a base of the new Billboard
Remarks:
This constructor is never used explicitly, but only inside Billboard::createFromBase.
See also:
Group

NVSG_API Billboard ( const Billboard & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant Billboard to copy from
Remarks:
This constructor is never used explicitly, but only inside Billboard::create.

virtual NVSG_API ~Billboard ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Billboard is decremented to zero.

Member Function Documentation

NVSG_API const Billboard* create ( ) [static]

Create a Billboard.

Returns:
A pointer to a constant Billboard.
Remarks:
The rotationAxis is initialized to the y-Axis, and this axis is marked to be used by setting screenAligned to false.

Reimplemented from Group.

NVSG_API const Billboard* createFromBase ( const Group & rhs ) [static]

Create a Billboard by copying from a Group.

Parameters:
rhs Reference to a constant Group to copy from
Returns:
A pointer to a constant Billboard.
Remarks:
All the data from the Group rhs is used as the base information for the newly created Billboard. Billboard-specific data is initialized just as if Billboard::create was called.
See also:
Group

virtual NVSG_API const Billboard* clone ( ) const [virtual]

Create a new Billboard by copying from this.

Returns:
A pointer to a constant Billboard.
Remarks:
The newly created Billboard is an exact copy of this.

Reimplemented from Group.

NVSG_API nvmath::Trafo getTrafoAxisAligned ( const nvmath::Vec3f & viewerPosition ) const

Get the current Trafo if the Billboard is not screen aligned.

Parameters:
viewerPosition A reference to the constant position of the viewer relative to the Billboard.
Returns:
An nvmath::Trafo, that represents the transformation of the Billboard.
Remarks:
The viewerPosition is defined relative to the Billboard. It is used as the new local z-axis.
Note:
If the Billboard is screen aligned, the result is undefined.

The Trafo is not defined, if the rotation axis and the new z-axis are collinear.

See also:
isScreenAligned, getRotationAxis, getTrafoScreenAligned

NVSG_API nvmath::Trafo getTrafoScreenAligned | ( | const nvmath::Vec3f & | viewerPosition,
 |  | const nvmath::Vec3f & | upVector
 | ) | const

Get the current Trafo if the Billboard is screen aligned.

Parameters:
viewerPosition | A reference to the constant position of the viewer relative to the Billboard.
upVector | A reference to the normalized constant up vector to use in the calculation.
Returns:
An nvmath::Trafo, that represents the transformation of the Billboard.
Remarks:
The viewerPosition is defined relative to the Billboard. It is used as the new local z-axis. The upVector also is in the Billboard's local coordinate system. It's projection on the plane perpendicular to the local z-axis is used as the new local y-axis.
Note:
If the Billboard is not screen aligned, the result is undefined.

If the upVector and the new z-axis are collinear, the minimal rotation from the default z-axis to the new z-axis is calculated.

See also:
isScreenAligned, getTrafoAxisAligned

bool isScreenAligned ( ) const [inline]

Query if the Billboard is to be screen aligned.

Returns:
true if the Billboard is to be screen aligned, otherwise false
Remarks:
A Billboard that is screen aligned is one that always rotates to stay aligned with the viewer; even when the viewer elevates, pitches, and rolls. That is, any rotation axis is ignored. The default is false.
See also:
getRotationAxis, getTrafo, setScreenAligned

void setScreenAligned ( bool on ) [inline]

Set the Billboard to be screen aligned.

Parameters:
on true, if Billboard is to be screen aligned, otherwise false
Remarks:
A Billboard that is screen aligned is one that it always rotates to stay aligned with the viewer; even when the viewer elevates, pitches, and rolls. That is, any rotation axis is ignored. The default is false.
See also:
isScreenAligned, setRotationAxis

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:
isScreenAligned, 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, setScreenAligned

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, isScreenAligned

Reimplemented from Group.

The documentation for this class was generated from the following file:
  • Billboard.h
Generated on Fri Aug 4 08:37:34 2006 for NVSGSDK by NVIDIA


Member List

Billboard Member List

This is the complete list of members for Billboard, including all inherited members.
activateClipPlane(size_t index) | Group | [inline]
addChild(const Node *child, size_t position=0xFFFFFFFF) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
Billboard() | Billboard | [protected]
Billboard(const Group &rhs) | Billboard | [explicit, protected]
Billboard(const Billboard &rhs) | Billboard | [protected]
calculateBoundingSphere() const | Group | [protected, virtual]
clone() const | Billboard | [virtual]
containsCgFx() const | Group | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Group | [virtual]
containsTransparentGeometry() const | Node |
create() | Billboard | [static]
createFromBase(const Group &rhs) | Billboard | [static]
nvsg::Group::createFromBase(const Node &rhs) | Group | [static]
deactivateClipPlane(size_t index) | Group | [inline]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getChild(size_t position) const | Group | [inline]
getChildPositions(const Node *node, std::vector< size_t > &positions) const | Group |
getClipPlane(size_t index) const | Group | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfFrames() const | Group | [virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getRotationAxis() const | Billboard | [inline]
getTrafoAxisAligned(const nvmath::Vec3f &viewerPosition) const | Billboard |
getTrafoScreenAligned(const nvmath::Vec3f &viewerPosition, const nvmath::Vec3f &upVector) const | Billboard |
Group() | Group | [protected]
Group(const Node &rhs) | Group | [explicit, protected]
Group(const Group &rhs) | Group | [protected]
hasChild(const Node *node) const | Group |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const Node *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Group | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Group | [virtual]
invalidateNumberOfFrames() const | Group | [virtual]
invalidateTransparencyContainment() | Node |
isClipPlaneActive(size_t index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Billboard | [virtual]
isScreenAligned() const | Billboard | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
postAddChild(size_t position) | Group | [protected, virtual]
postRemoveChild(size_t position) | Group | [protected, virtual]
preAddChild(size_t position) | Group | [protected, virtual]
preRemoveChild(size_t position) | Group | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeChild(const Node *child) | Group |
removeChild(size_t position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceChild(const Node *newChild, const Node *oldChild) | Group |
replaceChild(const Node *newChild, size_t position) | Group |
setAnnotation(const std::string &anno) | Node |
setClipPlane(size_t 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]
setScreenAligned(bool on) | Billboard | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Group | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Billboard() | Billboard | [protected, virtual]
~Group() | Group | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:34 2006 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 Fri Aug 4 08:40:09 2006 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 Fri Aug 4 08:40:09 2006 for NVSGSDK by NVIDIA


Bitmap Class Reference

A Map with one bit per pixel. More...

#include <Bitmap.h>

Inheritance diagram for Bitmap:

[legend]
Collaboration diagram for Bitmap:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API const Bitmap * | clone (void) const
Create a new Bitmap by copying from this.

NVSG_API const nvmath::Vec4f & | getColor (void) const
Get the color of the 1-bits in the Bitmap.

NVSG_API void | setColor (const nvmath::Vec4f &color)
Set the color of the 1-bits in the Bitmap.

Static Public Member Functions

NVSG_API const Bitmap * | create (size_t width, size_t height, unsigned char *data)
Create a Bitmap.

Protected Member Functions

NVSG_API | Bitmap (size_t width, size_t height, unsigned char *data)
Protected constructor to prevent explicit creation.

NVSG_API | Bitmap (const Bitmap &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Bitmap (void)
Protected destructor to prevent explicit creation.

Detailed Description

A Map with one bit per pixel.

Namespace: nvsg
Remarks:
A Bitmap can be used as a Map, i.e. for on-screen menus or display of data. A one(1) bit represents one pixel in the specified color, all zero(0) bits represent a transparent pixel.
See also:
Map, MapElement

Constructor & Destructor Documentation

NVSG_API Bitmap | ( | size_t | width,
 |  | size_t | height,
 |  | unsigned char * | data
 | ) | [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Bitmap::create.

NVSG_API Bitmap ( const Bitmap & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to a constant Bitmap to copy from
Remarks:
This constructor is never used explicitly, but only inside Bitmap::create.

virtual NVSG_API ~Bitmap ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Bitmap is decremented to zero.

Member Function Documentation

NVSG_API const Bitmap* create | ( | size_t | width,
 |  | size_t | height,
 |  | unsigned char * | data
 | ) | [static]

Create a Bitmap.

Returns:
A pointer to a constant Bitmap.
Remarks:
A Map of size width times height with one bit per pixel is created, using the data located at data. The color is initialized to opaque white (1.0,1.0,1.0,1.0).
See also:
Map

virtual NVSG_API const Bitmap* clone ( void ) const [virtual]

Create a new Bitmap by copying from this.

Returns:
A pointer to a constant Bitmap.
Remarks:
The newly created Bitmap is an exact copy of this.

Implements Map.

const nvmath::Vec4f & getColor ( void ) const [inline]

Get the color of the 1-bits in the Bitmap.

Returns:
A reference to the constant color of the Bitmap. The default color is opaque white (1.0,1.0,1.0,1.0).

void setColor ( const nvmath::Vec4f & color ) [inline]

Set the color of the 1-bits in the Bitmap.

Parameters:
color A reference to the constant color of the Bitmap.
Remarks:
This color is used for every 1-bits of the Bitmap. The 0-bits are completely transparent. The default color is opaque white (1.0,1.0,1.0,1.0).

The documentation for this class was generated from the following file:
  • Bitmap.h
Generated on Fri Aug 4 08:37:35 2006 for NVSGSDK by NVIDIA


Member List

Bitmap Member List

This is the complete list of members for Bitmap, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
Bitmap(size_t width, size_t height, unsigned char *data) | Bitmap | [protected]
Bitmap(const Bitmap &rhs) | Bitmap | [protected]
clone(void) const | Bitmap | [virtual]
create(size_t width, size_t height, unsigned char *data) | Bitmap | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getColor(void) const | Bitmap | [inline]
getData() const | Map | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHeight() const | Map | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getWidth() const | Map | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
Map(size_t width, size_t height, size_t bitsPerPixel, unsigned char *data) | Map | [protected]
Map(const Map &rhs) | Map | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setColor(const nvmath::Vec4f &color) | Bitmap | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Bitmap(void) | Bitmap | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Map() | Map | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:35 2006 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

virtual NVSG_API const BlendAttribute * | clone () const
Create a new BlendAttribute by copying from this.

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.

Static Public Member Functions

NVSG_API const BlendAttribute * | create ()
Create a BlendAttribute.

NVSG_API const BlendAttribute * | createFromBase (const StateAttribute &rhs)
Create a BlendAttribute by copying from a StateAttribute.

Protected Member Functions

NVSG_API | BlendAttribute ()
Protected constructor to prevent explicit creation.

NVSG_API | BlendAttribute (const StateAttribute &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | BlendAttribute (const BlendAttribute &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~BlendAttribute ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside BlendAttribute::create.

NVSG_API BlendAttribute ( const StateAttribute & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant StateAttribute to use as a base of the new BlendAttribute.
Remarks:
This constructor is never used explicitly, but only inside BlendAttribute::createFromBase.
See also:
StateAttribute

NVSG_API BlendAttribute ( const BlendAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant BlendAttribute to copy from.
Remarks:
This constructor is never used explicitly, but only inside BlendAttribute::create.

virtual NVSG_API ~BlendAttribute ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the BlendAttribute is decremented to zero.

Member Function Documentation

NVSG_API const BlendAttribute* create ( ) [static]

Create a BlendAttribute.

Returns:
A pointer to a constant BlendAttribute.
Remarks:
The defaults of a BlendAttribute is BF_ONE for the source and BF_ZERO for the destination function. This way, a BlendAttribute resembles the normal drawing mode without any blending.

NVSG_API const BlendAttribute* createFromBase ( const StateAttribute & rhs ) [static]

Create a BlendAttribute by copying from a StateAttribute.

Parameters:
rhs Reference to the constant StateAttribute to copy from
Returns:
A pointer to a constant BlendAttribute.
Remarks:
All the data from the StateAttribute rhs is used as the base information for the newly created BlendAttribute. BlendAttribute specific data is initialized as if BlendAttribute::create was called.
See also:
StateAttribute

virtual NVSG_API const BlendAttribute* clone ( ) const [virtual]

Create a new BlendAttribute by copying from this.

Returns:
A pointer to a constant BlendAttribute.
Remarks:
The newly created BlendAttribute is an exact copy of this.

Implements StateAttribute.

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 Fri Aug 4 08:37:36 2006 for NVSGSDK by NVIDIA


Member List

BlendAttribute Member List

This is the complete list of members for BlendAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
BlendAttribute() | BlendAttribute | [protected]
BlendAttribute(const StateAttribute &rhs) | BlendAttribute | [explicit, protected]
BlendAttribute(const BlendAttribute &rhs) | BlendAttribute | [protected]
clone() const | BlendAttribute | [virtual]
create() | BlendAttribute | [static]
createFromBase(const StateAttribute &rhs) | BlendAttribute | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDestinationFunction() const | BlendAttribute | [inline]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
getSourceFunction() const | BlendAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | BlendAttribute | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent() const | BlendAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const BlendAttribute &rhs) | BlendAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setBlendFunctions(BlendFunction sourceFunction, BlendFunction destinationFunction) | BlendAttribute |
setName(const std::string &name) | Object |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~BlendAttribute() | BlendAttribute | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:37:36 2006 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 const Animation<
nvmath::Trafo > * 		getAnimation () const
Get the Animation of type nvmath::Trafo.

NVSG_API const nvmath::Mat44f & | getMatrix (size_t frame) const
Calculate the transformation of an animation frame.

NVSG_API float | getWeight () const
Get the weight of this Bone.

NVSG_API void | setAnimation (const Animation< nvmath::Trafo > *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() (size_t 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

const Animation< nvmath::Trafo > * 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 ( size_t 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 ( const Animation< nvmath::Trafo > * 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() | ( | size_t | 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 Fri Aug 4 08:38:35 2006 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(size_t frame) const | Bone |
getWeight() const | Bone | [inline]
operator()(size_t frame, const nvmath::Vec4f &v) const | Bone |
operator=(const Bone &rhs) | Bone |
operator==(const Bone &b) const | Bone | [inline]
setAnimation(const Animation< nvmath::Trafo > *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 Fri Aug 4 08:38:35 2006 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 Fri Aug 4 08:36:30 2006 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 Fri Aug 4 08:36:30 2006 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 Fri Aug 4 08:38:52 2006 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, 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 Fri Aug 4 08:38:52 2006 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 Fri Aug 4 08:38:54 2006 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, 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 Fri Aug 4 08:38:54 2006 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 const Camera * | clone (void) const=0
Interface for cloning 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 size_t | getNumberOfHeadLights (void) const
Get the number of headlights attached to this Camera.

NVSG_API const LightSource * | getHeadLight (size_t index) const
Get the headlight at position index.

NVSG_API void | addHeadLight (const LightSource *light)
Add a headlight to this Camera.

NVSG_API void | removeHeadLight (size_t 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.

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.

virtual NVSG_API | ~Camera (void)
Protected destructor to prevent explicit creation.

NVSG_API Camera & | operator= (const Camera &rhs)
Protected assignment operator.

virtual NVSG_API void | validateIncarnation (void) const
Validate the Incarnation.

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

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

virtual NVSG_API ~Camera ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Camera is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

virtual NVSG_API const Camera* clone ( void ) const [pure virtual]

Interface for cloning a Camera.

Returns:
A pointer to a constant Camera
Remarks:
This overloading of the clone function is provided so that a common clone operator returns a pointer to a constant Camera, not only to a constant Object.

Implemented in ParallelCamera, and PerspectiveCamera.

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.
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

size_t 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

const LightSource * getHeadLight ( size_t index ) const [inline]

Get the headlight at position index.

Parameters:
index Index of headlight to get
Returns:
A pointer to the constant LightSource 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 ( const LightSource * light )

Add a headlight to this Camera.

Parameters:
light A pointer to the constant LightSource to add as a 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 ( size_t 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.
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.

Implemented in ParallelCamera, and PerspectiveCamera.

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

virtual NVSG_API void validateIncarnation ( void ) const [protected, 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.

The documentation for this class was generated from the following file:
  • Camera.h
Generated on Fri Aug 4 08:37:38 2006 for NVSGSDK by NVIDIA


Member List

Camera Member List

This is the complete list of members for Camera, including all inherited members.
addHeadLight(const LightSource *light) | Camera |
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
calcNearFarDistances(const nvmath::Sphere3f &sphere) | Camera |
Camera(void) | Camera | [protected]
Camera(const Camera &rhs) | Camera | [protected]
clearHeadLights(void) | Camera |
clone(void) const=0 | Camera | [pure virtual]
determineCullCode(const nvmath::Sphere3f &sphere) const=0 | Camera | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAspectRatio(void) const | Camera | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDirection(void) const | Camera | [inline]
getFarDistance(void) const | Camera | [inline]
getFocusDistance(void) const | Camera | [inline]
getHeadLight(size_t index) const | Camera | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInverseProjection(void) const=0 | Camera | [pure virtual]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
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]
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 |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isAutoClipPlanes(void) const | Camera | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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 | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Camera &rhs) | Camera | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [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]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHeadLight(size_t index) | Camera |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
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]
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 |
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]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | Camera | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
zoom(float factor) | Camera | [inline]
zoom(const nvmath::Sphere3f &sphere, float fovy=-1.0f) | Camera |
~Camera(void) | Camera | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:38 2006 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

virtual NVSG_API const CgFx * | clone () const
Returns a deep-copy of this 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 const CgFxEffect * | 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 const CgFx * | create ()
Instantiates a CgFx state attribute.

Protected Member Functions

CgFx ()
Constructs a CgFx object.

CgFx (const CgFx &rhs)
Constructs a CgFx object as a copy from another CgFx object.

virtual | ~CgFx ()
Destructs a CgFx object.

Detailed Description

A StateAttribute to apply render effects that are compliant to the Cg 1.4 standard.

Namespace: nvsg

Constructor & Destructor Documentation

CgFx ( ) [protected]

Constructs a CgFx object.

Remarks:
This constructor will be implicitly called through the static member function CgFx::create.

CgFx ( const CgFx & rhs ) [protected]

Constructs a CgFx object as a copy from another CgFx object.

Remarks:
This copy constructor will be implicitly called through the member function CgFx::clone.

virtual ~CgFx ( ) [protected, virtual]

Destructs a CgFx object.

Remarks:
This destructor will be implicitly called if the reference count for a CgFx object changes from one to zero.

Member Function Documentation

NVSG_API const CgFx* create ( ) [static]

Instantiates a CgFx state attribute.

Returns:
The function returns a pointer to the newly created const CgFx object.
Remarks:
The function only instantiates a CgFx attribute. It does not initialize a certain render effect. To do this you need to request write-access to the embedded CgFxEffect object of the newly created CgFx attribute, and then call either CgFxEffect::createFromFile or CgFxEffect::createFromLump on the writable CgFxEffect object (see example code below).

After the effect is created and initialized, you certainly want to apply it to a certain geometry of your render Scene. To do so, the CgFx attribute needs to be added to a StateSet, which in turn is assigned to a Drawable, utilizing the GeoNode interface.
Example:
This example shows how to assign a sample effect to a certain geometry.
 bool assignEffect( const GeoNode * node
                  , const Drawable * primitives
                  , const std::string& cgfxFile )
 {
     const CgFx * cgfx = CgFx::create();
     CgFxEffect * effect = nvutil::beginEdit(cgfx->getEffect());
     std::string err;
     if ( !effect->createFromFile(cgfxFile, err) )
     {
       nvutil::IO::errorMessage("effect creation failed", err, true);
       return false;
     }
     // effect successfully created and initialized

     // write-access no longer needed - release it
     nvutil::endEdit(effect);

     // see if a StateSet is already assigned to the geometry
     const StateSet * stateSet = node->getStateSet(primitives);
     if ( !stateSet )
     { // no StateSet assigned right now - create one and assign it
         stateSet = StateSet::create();
         GeoNode * editNode = nvutil::beginEdit(node);
         editNode->addGeometry(primitives, stateSet);
         nvutil::endEdit(editNode);
     }

     // stateSet should be valid and correctly assigned if we get here
     NVSG_ASSERT(stateSet);
     NVSG_ASSERT(stateSet==node->getStateSet(primitives));

     // add the CgFx attribute, so the render effect will be applied to the geometry
     StateSet * editStateSet = nvutil::beginEdit(stateSet);
     editStateSet->addAttribute(cgfx);
     nvutil::endEdit(editStateSet);

     return true;
 }
See also:
GeoNode, GeoNode::addGeometry, Drawable, StateSet, StateSet::addAttribute, nvutil::beginEdit, nvutil::endEdit, NVSG Objects

virtual NVSG_API const CgFx* clone ( ) const [virtual]

Returns a deep-copy of this CgFx object.

Returns:
The function returns a pointer to the const CgFx object that was created as a deep-copy of this CgFx object.
Remarks:
The function performs a deep-copy of this CgFx attribute. However, TextureImages that might be associated to effect samplers will not be deep-copied, but instead only a reference count will be incremented for this object. The reason for this is that the source images might have already been uploaded, and therefore the corresponding image data might have been released in turn. Hence, if we would deep-copy TextureImages as well, such a scenario would require a reload and a subsequent upload of the images. The reload, however, is not always possible (e.g. for images that have been created from a lump of raw RGBA data).

In cases where a deep-copy of associated TextureImages is required for some reason, this must be performed manually after the clone was instantiated. The below example shows some code that performs this task.
Example:
 const CgFx * cgfxClone(const CgFx * srcCgFx)
 {
     NVSG_ASSERT(srcCgFx);
     const CgFx * theClone = srcCgFx->clone();
     CgFxEffect * effect = nvutil::beginEdit(theClone->getEffect());
     size_t numSamplers = effect->getNumberOfSamplers();
     for ( size_t i=0; i<numSamplers; ++i )
     {
         CgFxParameter sampler = effect->getSampler(i);
         const TextureImage * img = effect->getSamplerTextureImage(sampler);
         if ( img )
         {
             const TextureImage * imgClone =  img->clone();
             effect->setSamplerTextureImageSpec(sampler, "", imgClone)
         }
     }
     nvutil::endEdit(effect);
     return theClone;
 }
See also:
TextureImage

Implements StateAttribute.

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 (CgFx::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:
CgFx::clone, CgFx::operator=()

Reimplemented from Object.

NVSG_API const CgFxEffect* 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 nvutil::beginEdit. After you finished the write-access, it is essential to call nvutil::endEdit on the writable object. Omitting the nvutil::endEdit call might cause your application to become deadlocked in a multithreaded environment.
Example:
   const CgFx * cgfx;
   [...]
   // assume a valid CgFx object here

   //
   CgFxEffect * effect = nvutil::beginEdit(cgfx->getEffect());
   // write access the embedded effect
   [...]
   // release the writable effect after finishing write-access
   nvutil::endEdit(effect);

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 Fri Aug 4 08:37:43 2006 for NVSGSDK by NVIDIA


Member List

CgFx Member List

This is the complete list of members for CgFx, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
CgFx() | CgFx | [protected]
CgFx(const CgFx &rhs) | CgFx | [protected]
clone() const | CgFx | [virtual]
create() | CgFx | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | CgFx | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getEffect() const | CgFx |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | CgFx | [virtual]
isEquivalent(const Object *object, bool ignoreNames, bool deepCompare) const | CgFx | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent() const | CgFx | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const CgFx &rhs) | CgFx |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
unloadPrograms() | CgFx |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~CgFx() | CgFx | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:37:43 2006 for NVSGSDK by NVIDIA


CgFxEffect Class Reference

Abstracts a render effect to be applied to a specific geometry. More...

#include <CgFx.h>

Inheritance diagram for CgFxEffect:

[legend]
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_VIEWT,
TRAFO_PROJECTIONT, TRAFO_WORLDI, TRAFO_MODELI = TRAFO_WORLDI, TRAFO_VIEWI,
TRAFO_PROJECTIONI, TRAFO_WORLDIT, TRAFO_MODELIT = TRAFO_WORLDIT, TRAFO_VIEWIT,
TRAFO_PROJECTIONIT, TRAFO_WORLDVIEW, TRAFO_MODELVIEW = TRAFO_WORLDVIEW, TRAFO_WORLDVIEWPROJECTION,
TRAFO_MODELVIEWPROJECTION = TRAFO_WORLDVIEWPROJECTION, TRAFO_WORLDVIEWT, TRAFO_MODELVIEWT = TRAFO_WORLDVIEWT, TRAFO_WORLDVIEWPROJECTIONT,
TRAFO_MODELVIEWPROJECTIONT = TRAFO_WORLDVIEWPROJECTIONT, TRAFO_WORLDVIEWI, TRAFO_MODELVIEWI = TRAFO_WORLDVIEWI, TRAFO_WORLDVIEWPROJECTIONI,
TRAFO_MODELVIEWPROJECTIONI = TRAFO_WORLDVIEWPROJECTIONI, TRAFO_WORLDVIEWIT, TRAFO_MODELVIEWIT = TRAFO_WORLDVIEWIT, TRAFO_WORLDVIEWPROJECTIONIT,
TRAFO_MODELVIEWPROJECTIONIT = TRAFO_WORLDVIEWPROJECTIONIT
}
Enumeration type to identify specific transforms. More...

Public Member Functions

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 size_t | getNumberOfParameterAnnotations (CgFxParameter param) const
Returns the number of annotations available for a specified parameter.

NVSG_API CgFxAnnotation | getParameterAnnotation (CgFxParameter param, size_t 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 size_t | getNumberOfTechniqueAnnotations (CgFxTechnique tech) const
Returns the number of annotations available for a specified technique.

NVSG_API CgFxAnnotation | getTechniqueAnnotation (CgFxTechnique tech, size_t 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 size_t | getNumberOfPassAnnotations (CgFxPass pass) const
Returns the number of annotations available for a specified render pass.

NVSG_API CgFxAnnotation | getPassAnnotation (CgFxPass pass, size_t 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 size_t | getAnnotationValueSize (CgFxAnnotation anno) const
Returns the size in bytes of the annotation value.

NVSG_API size_t | 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 size_t | getNumberOfArrayParameterElements (CgFxParameter param) const
Returns the array size of the specified array parameter.

NVSG_API CgFxParameter | getArrayParameterElement (CgFxParameter param, size_t index) const
Returns the array element at a specified zero-based index.

NVSG_API size_t | getNumberOfStructParameterMembers (CgFxParameter param) const
Returns the number of members for the specifies struct parameter.

NVSG_API CgFxParameter | getStructParameterMember (CgFxParameter param, size_t 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 size_t | getParameterValueSize (CgFxParameter param) const
Returns the size in bytes of the parameter value.

NVSG_API size_t | 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 | 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 | 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 size_t | getNumberOfTransforms () const
Returns the number of transform parameters available.

NVSG_API CgFxParameter | getTransform (size_t 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 size_t | getNumberOfTweakables () const
Returns the number of alterable effect parameters (so called 'tweakables').

NVSG_API CgFxParameter | getTweakable (size_t 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 size_t | getNumberOfLights () const
Returns the number of effect lights available.

NVSG_API CgFxParameter | getLight (size_t 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 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 | 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 size_t | getNumberOfSamplers () const
Returns the number of sampler available.

NVSG_API CgFxParameter | getSampler (size_t 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 bool | setSamplerTextureImageSpec (CgFxParameter param, const std::string &file, const TextureImage *image=NULL)
Lets the user re-specify a sampler's texture image.

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 const TextureImage * | getSamplerTextureImage (CgFxParameter param) const
Returns the texture image assigned to the specified sampler parameter.

NVSG_API const TextureImage * | reloadSamplerTextureImage (CgFxParameter param) const
Reloads the texture image of the specified sampler parameter.

NVSG_API size_t | 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 | isMipmapSamplerState (CgFxParameter param) const
Returns whether the sampler state for the specified sampler requires mipmap generation.

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 size_t | getNumberOfTechniques () const
Returns the number of techniques defined for this effect.

NVSG_API CgFxTechnique | getTechnique (size_t 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 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 size_t | getNumberOfPasses (CgFxTechnique tech) const
Returns the number of render passes defined for the specified technique.

NVSG_API CgFxPass | getPass (CgFxTechnique tech, size_t 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 (size_t index)
Applies the specified render pass.

NVSG_API void | resetPass (size_t index)
Resets the specified render pass.

NVSG_API size_t | 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 | 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 size_t | getNumberOfProgramParameters (CgFxProgram prog) const
Returns the number of parameters passed to the specified program.

NVSG_API CgFxParameter | getProgramParameter (CgFxProgram prog, size_t 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 as the associated CgFx attribute gets instantiated through CgFx::create. 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 const CgFxEffect object. If you need to access the non-const interface of that object, you have to pass the const object to nvutil::beginEdit which, in turn, gives you access to the non-const interface of the CgFxEffect object. Note that you must release write-access through nvutil::endEdit when write-access is no longer required. Otherwise, this might result in undefined runtime behavior!

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_VIEWT | Indicates a transposed transform from world space to eye space.
TRAFO_PROJECTIONT | 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_VIEWI | Indicates a transform from eye space to world space.
TRAFO_PROJECTIONI | 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_VIEWIT | Indicates a transposed transform from eye space to world space.
TRAFO_PROJECTIONIT | 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_WORLDVIEWPROJECTIONT | Indicates a transposed transform from object space to clip space.
TRAFO_MODELVIEWPROJECTIONT | 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_WORLDVIEWPROJECTIONI | Indicates a transform from clip space to object space.
TRAFO_MODELVIEWPROJECTIONI | 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_WORLDVIEWPROJECTIONIT | Indicates a transposed transform from clip space to object space.
TRAFO_MODELVIEWPROJECTIONIT | Indicates a transposed transform from clip space to object space.

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:
 // first create a CgFx state attribute
 const nvsg::CgFx * cgfx = nvsg::CgFx::create();
 // get writable access to the embedded CgFxEffect object from the attribute
 nvsg::CgFxEffect * effect = nvutil::beginEdit(cgfx->getEffect());
 // create the effect from the specified source file
 std::string err;
 if ( !effect->createFromFile("c:\effects\fancy.cgfx", err) )
 {
     nvutil::IO::errorMessage("effect creation failed", err, true);
     return false;
 }
 // effect creation succeeded - go ahead

 // release write access if not needed any longer!
 nvutil::endEdit(effect);
 // ...
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" // for beginEdit/endEdit
 #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"
 );

 const CgFx * cgfx = CgFx::create();
 CgFxEffect * effect = beginEdit(cgfx->getEffect());

 std::string err;
 if ( !effect->createFromLump(visualizeNormals, err) )
 {
     errorMessage("effect creation failed", err, true);
     return false;
 }
 // effect creation succeeded - go ahead

 // release write access if not needed any longer!
 endEdit(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)
 {
     const 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)
 {
     const 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 size_t 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)
 {
     size_t numAnnos = effect->getNumberOfParameterAnnotations(param);
     for ( size_t 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,
 |  | size_t | 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 effect and a valid parameter here
 size_t numAnnos = effect->getNumberOfParameterAnnotations(param);

 for ( size_t 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 size_t 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)
 {
     size_t numAnnos = effect->getNumberOfTechniqueAnnotations(tech);
     for ( size_t 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,
 |  | size_t | 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 effect and a valid technique here
 size_t numAnnos = effect->getNumberOfTechniqueAnnotations(tech);

 for ( size_t 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 size_t 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)
 {
     size_t numAnnos = effect->getNumberOfPassAnnotations(pass);
     for ( size_t 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,
 |  | size_t | 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 effect and a valid pass here
 size_t numAnnos = effect->getNumberOfPassAnnotations(pass);

 for ( size_t 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 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 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 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 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 size_t 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 size_t 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 size_t 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,
 |  | size_t | 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 size_t 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,
 |  | size_t | 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 size_t 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 size_t 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 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 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 | object space to world space (transposed matrix)
ViewT | world space to eye space (transposed matrix)
ProjectionT | eye space to clip space (transposed matrix)
WorldI, ModelI | world space to object space
ViewI | eye space to world space
ProjectionI | clip space to eye space
WorldIT, ModelIT | world space to object space (transposed matrix)
ViewIT | eye space to world space (transposed matrix)
ProjectionIT | clip space to eye space (transposed matrix)
WorldView, ModelView | object space to eye space
WorldViewProjection, ModelViewProjection | object space to clip space
WorldViewT, ModelViewT | object space to eye space (transposed matrix)
WorldViewProjectionT, ModelViewProjectionT | object space to clip space (transposed matrix)
WorldViewI, ModelViewI | eye space to object space
WorldViewProjectionI, ModelViewProjectionI | clip space to object space
WorldViewIT, ModelViewIT | eye space to object space (transposed matrix)
WorldViewProjectionIT, ModelViewProjectionIT | 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 size_t 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 ( size_t 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)
 {
   size_t numTrafos = effect->getNumberOfTransforms();
   for ( size_t 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 size_t 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 ( size_t 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 size_t 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 ( size_t 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 effect here
 size_t numLights = effect->getNumberOfLigths();
 for ( size_t 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 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 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 size_t 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 ( size_t 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 bool setSamplerTextureImageSpec | ( | CgFxParameter | param,
 |  | const std::string & | file,
 |  | const TextureImage * | image = NULL
 | ) |

Lets the user re-specify a sampler's texture image.

Parameters:
param | Handle to the sampler.
file | Specifies the path and file name of an optional texture file.
image | Pointer to an optional, pre-generated TextureImage object.
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. A previously specified texture image will be unreferenced by this function.

A texture image can be specified by either a texture image file, by a valid TextureImage object, or both.

If no TextureImage object is passed - that is, if NULL is passed for image - the function looks up the file specified by file and tries to load a texture image from it. If this was successful, the new loaded image will be taken as new texture image for the specified sampler. If a valid TextureImage object is passed through image, that image is taken as new texture image for the sampler. If in the latter case a valid filename was passed through file, the function does not load an image from the file but assumes that the specified file directly corresponds to the passed TextureImage object.

The behaviour is undefined if the type of the texture image doesn't match the sampler's type. It would be an error, e.g. if you specify a 2D texture image for a samplerCUBE parameter.
See also:
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 const TextureImage* 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 const TextureImage object 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 const TextureImage* reloadSamplerTextureImage ( CgFxParameter param ) const

Reloads the texture image of the specified sampler parameter.

Parameters:
param Handle to the sampler.
Returns:
A pointer to the reloaded TextureImage if successful. Otherwise, the function returns NULL.
Remarks:
To successfully reload a sampler's texture image, there must be a texture file associated from which to re-load the image. This could be done in beforehand by calling CgFxEffect::setSamplerTextureImageSpec.

A reload, for example, might be necessary after a certain texture environment has been changed (e.g. texture filter), or if for some reason the image data were released before the image was uploaded to the underlying graphics hardware.

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 size_t 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 isMipmapSamplerState ( CgFxParameter param ) const

Returns whether the sampler state for the specified sampler requires mipmap generation.

Parameters:
param 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 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 size_t 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 effect here
 size_t numTechs = effect->getNumberOfTechniques();
 for ( size_t 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 ( size_t 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 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 size_t 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,
 |  | size_t | 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 ( size_t 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;
 // ...
 // assume a valid CgFx attribute here
 CgFxEffect * effect = nvutil::beginEdit(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();
   size_t numPasses = effect->getNumberOfPasses(tech);
   size_t currPass = 0;
   do
   {
       effect->applyPass(currPass);
       DrawGeometry(); // send geometry down the pipeline
       effect->resetPass(currPass);
   } while (++currPass < numPasses)
 }
 nvutil::endEffect(effect);
See also:
CgFxEffect::setCurrentTechnique

NVSG_API void resetPass ( size_t 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 size_t 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 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 size_t 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,
 |  | size_t | 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 Fri Aug 4 08:37:42 2006 for NVSGSDK by NVIDIA


Member List

CgFxEffect Member List

This is the complete list of members for CgFxEffect, including all inherited members.
applyPass(size_t index) | CgFxEffect |
compileProgram(CgFxProgram prog) | CgFxEffect |
createFromFile(const std::string &file, std::string &err) | CgFxEffect |
createFromLump(const std::string &lump, std::string &err) | CgFxEffect |
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnnotationName(CgFxAnnotation anno) const | CgFxEffect |
getAnnotationTypeString(CgFxAnnotation anno) const | CgFxEffect |
getAnnotationValueSize(CgFxAnnotation anno) const | CgFxEffect |
getArrayParameterElement(CgFxParameter param, size_t 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 |
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(size_t 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 |
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, size_t 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, size_t index) const | CgFxEffect |
getPassAnnotation(CgFxPass pass, size_t 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 |
getProgramParameter(CgFxProgram prog, size_t index) const | CgFxEffect |
getProgramProfile(CgFxProgram prog) const | CgFxEffect |
getSampler(size_t 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 |
getSamplerTextureImage(CgFxParameter param) 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, size_t index) const | CgFxEffect |
getStructParameterMemberByName(CgFxParameter param, const std::string &member) const | CgFxEffect |
getTechnique(size_t index) const | CgFxEffect |
getTechniqueAnnotation(CgFxTechnique tech, size_t index) const | CgFxEffect |
getTechniqueAnnotationByName(CgFxTechnique tech, const std::string &name) const | CgFxEffect |
getTechniqueByName(const std::string &name) const | CgFxEffect |
getTechniqueName(CgFxTechnique tech) const | CgFxEffect |
getTransform(size_t index) const | CgFxEffect |
getTransformType(CgFxParameter param) const | CgFxEffect |
getTweakable(size_t 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 param) 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 |
isSamplerCubeParameter(CgFxParameter param) const | CgFxEffect |
isSamplerParameter(CgFxParameter param) const | CgFxEffect |
isSamplerRectParameter(CgFxParameter param) const | CgFxEffect |
isScalarParameter(CgFxParameter param) const | CgFxEffect |
isStringAnnotation(CgFxAnnotation anno) const | CgFxEffect |
isStringParameter(CgFxParameter param) const | CgFxEffect |
isStructParameter(CgFxParameter param) 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 |
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
reloadSamplerTextureImage(CgFxParameter param) const | CgFxEffect |
resetLightValues(CgFxParameter param) | CgFxEffect |
resetMaterialValues(CgFxParameter param) | CgFxEffect |
resetPass(size_t index) | 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 |
setSamplerTextureImageSpec(CgFxParameter param, const std::string &file, const TextureImage *image=NULL) | 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_MODELIT enum value | CgFxEffect |
TRAFO_MODELT enum value | CgFxEffect |
TRAFO_MODELVIEW enum value | CgFxEffect |
TRAFO_MODELVIEWI enum value | CgFxEffect |
TRAFO_MODELVIEWIT enum value | CgFxEffect |
TRAFO_MODELVIEWPROJECTION enum value | CgFxEffect |
TRAFO_MODELVIEWPROJECTIONI enum value | CgFxEffect |
TRAFO_MODELVIEWPROJECTIONIT enum value | CgFxEffect |
TRAFO_MODELVIEWPROJECTIONT enum value | CgFxEffect |
TRAFO_MODELVIEWT enum value | CgFxEffect |
TRAFO_PROJECTION enum value | CgFxEffect |
TRAFO_PROJECTIONI enum value | CgFxEffect |
TRAFO_PROJECTIONIT enum value | CgFxEffect |
TRAFO_PROJECTIONT enum value | CgFxEffect |
TRAFO_UNKNOWN enum value | CgFxEffect |
TRAFO_VIEW enum value | CgFxEffect |
TRAFO_VIEWI enum value | CgFxEffect |
TRAFO_VIEWIT enum value | CgFxEffect |
TRAFO_VIEWT enum value | CgFxEffect |
TRAFO_WORLD enum value | CgFxEffect |
TRAFO_WORLDI enum value | CgFxEffect |
TRAFO_WORLDIT enum value | CgFxEffect |
TRAFO_WORLDT enum value | CgFxEffect |
TRAFO_WORLDVIEW enum value | CgFxEffect |
TRAFO_WORLDVIEWI enum value | CgFxEffect |
TRAFO_WORLDVIEWIT enum value | CgFxEffect |
TRAFO_WORLDVIEWPROJECTION enum value | CgFxEffect |
TRAFO_WORLDVIEWPROJECTIONI enum value | CgFxEffect |
TRAFO_WORLDVIEWPROJECTIONIT enum value | CgFxEffect |
TRAFO_WORLDVIEWPROJECTIONT enum value | CgFxEffect |
TRAFO_WORLDVIEWT enum value | CgFxEffect |
TransformType enum name | CgFxEffect |
validateCurrentTechnique() | CgFxEffect |
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
Generated on Fri Aug 4 08:37:42 2006 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 Fri Aug 4 08:40:08 2006 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 Fri Aug 4 08:40:08 2006 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.

virtual NVSG_API | ~CullData (void)
Destructor.

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 (size_t 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 size_t | getNumberOfChildren (void) const
Get the number of children of this CullData.

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 ) [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 ( size_t 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.

size_t 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 Fri Aug 4 08:37:44 2006 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]
balance(void) | CullData |
clone(const CullData *rhs) | CullData | [related]
CullData(CullCode cullCode) | CullData |
getChild(size_t i) const | CullData | [inline]
getCullCode(void) const | CullData | [inline]
getNumberOfChildren(void) const | CullData | [inline]
IAllocator() | IAllocator | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator!=(const CullData &lhs, const CullData &rhs) | CullData | [related]
operator==(const CullData &lhs, const CullData &rhs) | CullData | [related]
theAllocator typedef | IAllocator |
~CullData(void) | CullData | [virtual]
~IAllocator() | IAllocator | [inline, virtual]
Generated on Fri Aug 4 08:37:44 2006 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 (const nvsg::Scene *scene)
Override of the doApply method.

virtual NVSG_API nvsg::CullCode | cullCode (const nvsg::Drawable *p) const
Determine the CullCode of a nvsg::Drawable.

virtual NVSG_API nvsg::CullCode | cullCode (const nvsg::Node *p) const
Determine the CullCode of a nvsg::Node.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Determine the nvsg::CullData of p.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Determine the nvsg::CullData of p.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Determine the nvsg::CullData of p.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
Determine the nvsg::CullData of p.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
Determine the nvsg::CullData of p.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Determine the nvsg::CullData of p.

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *p)
Handle a nvsg::PrimitiveSet by determining its nvsg::CullCode.

virtual NVSG_API void | traverseLight (const nvsg::LightSource *p)
Handle a nvsg::LightSource by marking it as in (CC_IN).

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 two functions cullCode() for a nvsg::Drawable and a nvsg::Node.
Note:
A CullTraverser needs to have a valid nvsg::ViewState, so call setViewState() prior to apply.
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 ( const nvsg::Scene * scene ) [protected, virtual]

Override of the doApply method.

Parameters:
scene A pointer to the constant nvsg::Scene to cull.
Remarks:
The doApply method is the traversal entry point of a Traverser. After the traversal is done by ModelViewTraverser::doApply(), the resulting tree of nvsg::CullData is balanced and set as the current cull tree into the nvsg::ViewState.
See also:
CullData, nvsg::Scene, ModelViewTraverser, nvsg::ViewState

Reimplemented from Traverser.

virtual NVSG_API nvsg::CullCode cullCode ( const nvsg::Drawable * p ) const [protected, virtual]

Determine the CullCode of a nvsg::Drawable.

Parameters:
p A pointer to the constant nvsg::Drawable to determine the nvsg::CullCode of.
Returns:
The nvsg::CullCode of the nvsg::Drawable p.
Remarks:
The default implementation returns the nvsg::CullCode CC_IN.

Reimplemented in FrustumCullTraverser.

virtual NVSG_API nvsg::CullCode cullCode ( const nvsg::Node * p ) const [protected, virtual]

Determine the CullCode of a nvsg::Node.

Parameters:
p A pointer to the constant nvsg::Node to determine the nvsg::CullCode of.
Returns:
The nvsg::CullCode of the nvsg::Node p.
Remarks:
The default implementation returns the nvsg::CullCode CC_IN.

Reimplemented in FrustumCullTraverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Determine the nvsg::CullData of p.

Parameters:
p A pointer to the constant nvsg::Billboard to handle.
Remarks:
If p is partially visible (CC_PART), it is traversed and the nvsg::CullData of all its children are gathered beneath the nvsg::CullData of p.
See also:
handleGroup, handleLOD, handleSwitch, handleTransform

Reimplemented from ModelViewTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Determine the nvsg::CullData of p.

Parameters:
p A pointer to the constant nvsg::GeoNode to handle.
Remarks:
If p is partially visible (CC_PART), it is traversed and the nvsg::CullData of all its nvsg::Drawable objects is gathered beneath the nvsg::CullData of p.
See also:
traversePrimitiveSet

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Determine the nvsg::CullData of p.

Parameters:
p A pointer to the constant nvsg::Group to handle.
Remarks:
If p is partially visible (CC_PART), it is traversed and the nvsg::CullData of all its children are gathered beneath the nvsg::CullData of p.
See also:
handleBillboard, handleLOD, handleSwitch, handleTransform

Reimplemented from Traverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Determine the nvsg::CullData of p.

Parameters:
p A pointer to the constant nvsg::LOD to handle.
Remarks:
If p is partially visible (CC_PART), it is traversed and the nvsg::CullData of all its children are gathered beneath the nvsg::CullData of p.
See also:
handleBillboard, handleGroup, handleSwitch, handleTransform

Reimplemented from ModelViewTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Determine the nvsg::CullData of p.

Parameters:
p A pointer to the constant nvsg::Switch to handle.
Remarks:
If p is partially visible (CC_PART), it is traversed and the nvsg::CullData of all its children are gathered beneath the nvsg::CullData of p.
See also:
handleBillboard, handleGroup, handleLOD, handleTransform

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Determine the nvsg::CullData of p.

Parameters:
p A pointer to the constant nvsg::Transform to handle.
Remarks:
If p is partially visible (CC_PART), it is traversed and the nvsg::CullData of all its children are gathered beneath the nvsg::CullData of p.
See also:
handleBillboard, handleGroup, handleLOD, handleSwitch

Reimplemented from ModelViewTraverser.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * p ) [protected, virtual]

Handle a nvsg::PrimitiveSet by determining its nvsg::CullCode.

Parameters:
p A pointer to the constant nvsg::PrimitiveSet to handle.
Remarks:
The nvsg::CullCode of the nvsg::PrimitiveSet p is determined via the function cullCode() and the results are recorded in the nvsg::CullData tree.
See also:
cullCode

Reimplemented from Traverser.

virtual NVSG_API void traverseLight ( const nvsg::LightSource * p ) [protected, virtual]

Handle a nvsg::LightSource by marking it as in (CC_IN).

Parameters:
p A pointer to the constant nvsg::LightSource to handle.
Remarks:
All nvsg::LightSource objects are considered to be in.
See also:
traversePrimitiveSet

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • CullTraverser.h
Generated on Fri Aug 4 08:39:11 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
cullCode(const nvsg::Drawable *p) const | CullTraverser | [protected, virtual]
cullCode(const nvsg::Node *p) const | CullTraverser | [protected, virtual]
CullTraverser() | CullTraverser | [protected]
doApply(const nvsg::Scene *scene) | CullTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | ModelViewTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | CullTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | CullTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | CullTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | CullTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | CullTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | CullTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | ModelViewTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | ModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setViewState(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | CullTraverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | CullTraverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~CullTraverser(void) | CullTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:11 2006 for NVSGSDK by NVIDIA


DALData Class Reference

Device Abstraction Link Data. More...

#include <DAL.h>

Inheritance diagram for DALData:

[legend]
List of all members.

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

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 Fri Aug 4 08:37:45 2006 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]
Generated on Fri Aug 4 08:37:45 2006 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 Fri Aug 4 08:37:45 2006 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 Fri Aug 4 08:37:45 2006 for NVSGSDK by NVIDIA


DALHost Class Reference

Represents an object capable to host a Device Abstraction Link. More...

#include <DAL.h>

Inheritance diagram for DALHost:

[legend]
List of all members.

Public Member Functions

NVSG_API HDAL | storeDeviceAbstractionLinkData (unsigned int dataID, DALData *data) const
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
 | ) | const [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 Fri Aug 4 08:37:44 2006 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) const | DALHost | [inline]
Generated on Fri Aug 4 08:37:44 2006 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

size_t | denormalizedNormalsCount
The number of objects with denormalized normals.

size_t | 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

size_t denormalizedNormalsCount

The number of objects with denormalized normals.

size_t denormalizedNormalsNumber

The number of denormalized normals in those objects.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:04 2006 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 Fri Aug 4 08:39:04 2006 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

virtual NVSG_API const DepthAttribute * | clone () const
Create a new DepthAttribute by copying from this.

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.

Static Public Member Functions

NVSG_API const DepthAttribute * | create ()
Create a DepthAttribute.

NVSG_API const DepthAttribute * | createFromBase (const StateAttribute &rhs)
Create a DepthAttribute by copying from a StateAttribute.

Protected Member Functions

NVSG_API | DepthAttribute ()
Protected constructor to prevent explicit creation.

NVSG_API | DepthAttribute (const StateAttribute &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | DepthAttribute (const DepthAttribute &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~DepthAttribute ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside DepthAttribute::create.

NVSG_API DepthAttribute ( const StateAttribute & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant StateAttribute to use as a base of the new DepthAttribute.
Remarks:
This constructor is never used explicitly, but only inside DepthAttribute::createFromBase.
See also:
StateAttribute

NVSG_API DepthAttribute ( const DepthAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant DepthAttribute to copy from.
Remarks:
This constructor is never used explicitly, but only inside DepthAttribute::create.

virtual NVSG_API ~DepthAttribute ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the DepthAttribute is decremented to zero.

Member Function Documentation

NVSG_API const DepthAttribute* create ( ) [static]

Create a DepthAttribute.

Returns:
A pointer to a constant 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 const DepthAttribute* createFromBase ( const StateAttribute & rhs ) [static]

Create a DepthAttribute by copying from a StateAttribute.

Parameters:
rhs Reference to the constant StateAttribute to copy from
Returns:
A pointer to a constant DepthAttribute.
Remarks:
All the data from the StateAttribute rhs is used as the base information for the newly created DepthAttribute. DepthAttribute specific data is initialized as if DepthAttribute::create was called.
See also:
StateAttribute

virtual NVSG_API const DepthAttribute* clone ( ) const [virtual]

Create a new DepthAttribute by copying from this.

Returns:
A pointer to a constant DepthAttribute.
Remarks:
The newly created DepthAttribute is an exact copy of this.

Implements StateAttribute.

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 Fri Aug 4 08:37:46 2006 for NVSGSDK by NVIDIA


Member List

DepthAttribute Member List

This is the complete list of members for DepthAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | DepthAttribute | [virtual]
create() | DepthAttribute | [static]
createFromBase(const StateAttribute &rhs) | DepthAttribute | [static]
DepthAttribute() | DepthAttribute | [protected]
DepthAttribute(const StateAttribute &rhs) | DepthAttribute | [explicit, protected]
DepthAttribute(const DepthAttribute &rhs) | DepthAttribute | [protected]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDepthFunction() const | DepthAttribute | [inline]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, 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]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const DepthAttribute &rhs) | DepthAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setDepthFunction(nvsg::DepthFunction df) | DepthAttribute |
setDepthTestingEnabled(bool enabled) | DepthAttribute |
setDepthWritingEnabled(bool enabled) | DepthAttribute |
setName(const std::string &name) | Object |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~DepthAttribute() | DepthAttribute | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:37:46 2006 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 (const nvsg::Scene *scene)
Override of the doApply method.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Destripify the strips of this nvsg::GeoNode.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *p)
Gather the nvsg::LineStrips to destrip.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Gather the nvsg::QuadStrips to destrip.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
Gather the nvsg::TriFans to destrip.

virtual NVSG_API void | handleTriStrips (const 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 ( const nvsg::Scene * scene ) [protected, virtual]

Override of the doApply method.

Parameters:
scene A pointer to the constant nvsg::Scene 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 Traverser.

virtual NVSG_API void handleGeoNode ( const 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 Traverser.

virtual NVSG_API void handleLineStrips ( const 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 Traverser.

virtual NVSG_API void handleQuadStrips ( const 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 Traverser.

virtual NVSG_API void handleTriFans ( const 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 Traverser.

virtual NVSG_API void handleTriStrips ( const 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 Traverser.

The documentation for this class was generated from the following file:
  • DestrippingTraverser.h
Generated on Fri Aug 4 08:39:12 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
DestrippingTraverser(void) | DestrippingTraverser |
doApply(const nvsg::Scene *scene) | DestrippingTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | DestrippingTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | DestrippingTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | DestrippingTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | DestrippingTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | DestrippingTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~DestrippingTraverser(void) | DestrippingTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:12 2006 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

virtual NVSG_API const DirectedLight * | clone () const
Create a new DirectedLight by copying from this.

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.

Static Public Member Functions

NVSG_API const DirectedLight * | create ()
Create a DirectedLight.

NVSG_API const DirectedLight * | createFromBase (const LightSource &rhs)
Create a DirectedLight by copying from a LightSource.

Protected Member Functions

NVSG_API | DirectedLight ()
Protected constructor to prevent explicit creation.

NVSG_API | DirectedLight (const LightSource &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | DirectedLight (const DirectedLight &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~DirectedLight ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside DirectedLight::create.

NVSG_API DirectedLight ( const LightSource & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant LightSource to use as a base of the new DirectedLight
Remarks:
This constructor is never used explicitly, but only inside DirectedLight::createFromBase.
See also:
LightSource

NVSG_API DirectedLight ( const DirectedLight & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant DirectedLight to copy from
Remarks:
This constructor is never used explicitly, but only inside DirectedLight::create.

virtual NVSG_API ~DirectedLight ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the DirectedLight is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const DirectedLight* create ( ) [static]

Create a DirectedLight.

Returns:
A pointer to a constant DirectedLight.
Remarks:
A DirectedLight does not add any information to its base class LightSource.
See also:
LightSource

NVSG_API const DirectedLight* createFromBase ( const LightSource & rhs ) [static]

Create a DirectedLight by copying from a LightSource.

Parameters:
rhs A reference to the constant LightSource to copy from
Returns:
A pointer to a constant DirectedLight.
Remarks:
All the data from the LightSource rhs is used as the base information for the newly created DirectedLight.
See also:
LightSource

virtual NVSG_API const DirectedLight* clone ( ) const [virtual]

Create a new DirectedLight by copying from this.

Returns:
A pointer to a constant DirectedLight.
Remarks:
The newly created DirectedLight is an exact copy of this.

Implements LightSource.

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

void setOrientation ( const nvmath::Quatf & orientation ) [inline]

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 Fri Aug 4 08:37:47 2006 for NVSGSDK by NVIDIA


Member List

DirectedLight Member List

This is the complete list of members for DirectedLight, including all inherited members.
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | LightSource | [protected, virtual]
clone() const | DirectedLight | [virtual]
containsCgFx() const | Node | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | LightSource | [virtual]
containsTransparentGeometry() const | Node |
create() | DirectedLight | [static]
createFromBase(const LightSource &rhs) | DirectedLight | [static]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineTransparencyContainment() const | LightSource | [protected, virtual]
DirectedLight() | DirectedLight | [protected]
DirectedLight(const LightSource &rhs) | DirectedLight | [explicit, protected]
DirectedLight(const DirectedLight &rhs) | DirectedLight | [protected]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDiffuseColor() const | LightSource | [inline]
getDirection() const | DirectedLight | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames() const | LightSource | [inline, virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getOrientation() const | DirectedLight | [inline]
getParent(size_t index) const | Node | [inline]
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCgFxContainment() | Node | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Node | [virtual]
invalidateNumberOfFrames() const | Node | [virtual]
invalidateTransparencyContainment() | Node |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LightSource | [virtual]
isShadowCasting() const | LightSource | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const DirectedLight &rhs) | DirectedLight |
nvsg::LightSource::operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(const Animation< nvmath::Trafo > *animation) | LightSource |
setAnimationFrame(size_t frame) | LightSource |
setAnnotation(const std::string &anno) | Node |
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setDirection(const nvmath::Vec3f &direction) | DirectedLight |
setHints(unsigned short hints) | Node | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setOrientation(const nvmath::Quatf &orientation) | DirectedLight | [inline]
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | LightSource | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~DirectedLight() | DirectedLight | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LightSource() | LightSource | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:47 2006 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 const Drawable * | clone (void) const=0
Create a new Drawable by copying from this.

NVSG_API const nvmath::Sphere3f & | getBoundingSphere (void) const
Get the bounding sphere of this Drawable.

NVSG_API void | invalidateBoundingSphere (void)
Invalidate the bounding sphere of this Drawable.

virtual NVSG_API size_t | getNumberOfFrames (void) const
Get the number of animation frames.

NVSG_API void | invalidateNumberOfFrames (void) const
Invalidate the number of animation frames.

NVSG_API size_t | getNumberOfOwners (void) const
Get the number of owners of this Drawable.

NVSG_API const GeoNode * | getOwner (size_t index) const
Get the owning GeoNode at position index.

NVSG_API void | attachHighlightObject (const HighlightObject *obj=NULL)
Attach a HighlightObject to this Drawable.

NVSG_API const HighlightObject * | getHighlightObject (void) const
Get the attached HighlightObject.

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 | ~Drawable (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere (void) const=0
Interface for calculating the bounding sphere of this Drawable.

virtual NVSG_API void | validateIncarnation (void) const
Validate the nvutil::Incarnation.

virtual NVSG_API void | invalidateIncarnation (void)
Invalidate the nvutil::Incarnation.

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 getNumberOfFrames(), validateIncarnation(), and invalidateIncarnation().
See also:
nvutil::Incarnation, Object, PrimitiveSet, Shape

Constructor & Destructor Documentation

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

virtual NVSG_API ~Drawable ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Drawable is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

virtual NVSG_API const Drawable* clone ( void ) const [pure virtual]

Create a new Drawable by copying from this.

Returns:
A pointer to a constant Drawable.
Remarks:
The newly created Drawable is an exact copy of this.

Implemented in AnimatedQuads, AnimatedTriangles, IndependentPrimitiveSet, Lines, LineStrips, MeshedPrimitiveSet, Points, PrimitiveSet, QuadMeshes, Quads, QuadStrips, Shape, SkinnedTriangles, StrippedPrimitiveSet, Triangles, TriFans, and TriStrips.

NVSG_API const nvmath::Sphere3f& getBoundingSphere ( void ) const

Get the bounding sphere of this Drawable.

Returns:
A reference to a constant nvmath::Sphere3f that bounds the complete Drawable.
Remarks:
If the bounding sphere currently is marked as invalid, calculateBoundingSphere() is used to calculate it. If there is a highlight object attached, this is combined with the bounding sphere of the highlight object. Then the bounding sphere is marked as valid.
See also:
HighlightObject, calculateBoundingSphere, invalidateBoundingSphere

NVSG_API void invalidateBoundingSphere ( void )

Invalidate the bounding sphere of this Drawable.

Remarks:
If the bounding sphere currently is marked as invalid, the nvutil::Incarnation is increased, thus reporting a change up the tree hierarchy. Otherwise, the nvutil::Incarnation is only invalidated, but on all owners and on an attached highlight object the bounding sphere is invalidated, thus also reporting the change up the tree hierarchy.
See also:
HighlightObject, calculateBoundingSphere, getBoundingSphere

virtual NVSG_API size_t getNumberOfFrames ( void ) const [virtual]

Get the number of animation frames.

Returns:
The number of animation frames of this Drawable.
Remarks:
Objects derived from Drawable that have an Animation attached should return the number of frames of that Animation. The default implementation returns zero, thus indicating that there is no Animation attached.
See also:
Animation, invalidateNumberOfFrames

Reimplemented in AnimatedQuads, AnimatedTriangles, and SkinnedTriangles.

NVSG_API void invalidateNumberOfFrames ( void ) const

Invalidate the number of animation frames.

Remarks:
If the number of frames of an animation attached to the Drawable changes, this function should be called. It invalidates the number of frames of each owner, thus reporting the change up the tree hierarchy.
See also:
Animation, getNumberOfFrames

size_t getNumberOfOwners ( void ) const [inline]

Get the number of owners of this Drawable.

Returns:
Number of owners of this Drawable.
Remarks:
A Drawable that is part of one or more GeoNode objects holds a pointer back to each of those GeoNode objects. These are called the owners. So the number of owners tells you how often this Drawable is referenced in a scene tree.
See also:
GeoNode, getOwner

const GeoNode * getOwner ( size_t index ) const [inline]

Get the owning GeoNode at position index.

Parameters:
index Position of the GeoNode to get in the list of owners.
Returns:
A pointer to a constant GeoNode that has this Drawable as a child.
Remarks:
A Drawable that is part of one or more GeoNode objects, holds a pointer back to each of those GeoNode 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:
GeoNode, getNumberOfOwners

NVSG_API void attachHighlightObject ( const HighlightObject * obj = NULL )

Attach a HighlightObject to this Drawable.

Parameters:
obj Optional pointer to a constant 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

const HighlightObject * getHighlightObject ( void ) const [inline]

Get the attached HighlightObject.

Returns:
A pointer to the constant attached HighlightObject.
See also:
attachHighlightObject

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( void ) 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, invalidateBoundingSphere

Implemented in IndependentPrimitiveSet, MeshedPrimitiveSet, PrimitiveSet, Shape, and StrippedPrimitiveSet.

virtual NVSG_API void validateIncarnation ( void ) const [protected, 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 AnimatedQuads, AnimatedTriangles, PrimitiveSet, Shape, and SkinnedTriangles.

virtual NVSG_API void invalidateIncarnation ( void ) [protected, virtual]

Invalidate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this Drawable has increased and now is to be marked as invalid. It first increases the nvutil::Incarnation of all its owners, then its own nvutil::Incarnation is marked as invalid.
See also:
GeoNode, nvutil::Incarnation, validateIncarnation

Reimplemented from Object.

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 Object 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, Object

The documentation for this class was generated from the following file:
  • Drawable.h
Generated on Fri Aug 4 08:37:48 2006 for NVSGSDK by NVIDIA


Member List

Drawable Member List

This is the complete list of members for Drawable, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere(void) const=0 | Drawable | [protected, pure virtual]
clone(void) const=0 | Drawable | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | Drawable | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:48 2006 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

size_t | 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

size_t emptyCount

The number of empty objects of this type.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:04 2006 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 Fri Aug 4 08:39:04 2006 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

size_t | equivalentCount
The number of equivalent objects of this type.

size_t | 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

size_t equivalentCount

The number of equivalent objects of this type.

size_t 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 Fri Aug 4 08:39:04 2006 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 Fri Aug 4 08:39:04 2006 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

unsigned int & | operator[] (size_t i)
Random access operator to the indices of the Face.

const unsigned int & | operator[] (size_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<size_t 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[] ( size_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[] ( size_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 Fri Aug 4 08:37:48 2006 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[](size_t i) | Face | [inline]
operator[](size_t i) const | Face | [inline]
Generated on Fri Aug 4 08:37:48 2006 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

virtual NVSG_API const FaceAttribute * | clone () const
Create a new FaceAttribute by copying from this.

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.

Static Public Member Functions

NVSG_API const FaceAttribute * | create ()
Create a FaceAttribute.

NVSG_API const FaceAttribute * | createFromBase (const PrimitiveAttribute &rhs)
Create a FaceAttribute by copying from a PrimitiveAttribute.

Protected Member Functions

NVSG_API | FaceAttribute ()
Protected default constructor to prevent explicit creation.

NVSG_API | FaceAttribute (const PrimitiveAttribute &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | FaceAttribute (const FaceAttribute &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~FaceAttribute ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside FaceAttribute::create.

NVSG_API FaceAttribute ( const PrimitiveAttribute & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveAttribute to use as a base of the new FaceAttribute
Remarks:
This constructor is never used explicitly, but only inside FaceAttribute::createFromBase.
See also:
PrimitiveAttribute

NVSG_API FaceAttribute ( const FaceAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant FaceAttribute to copy from
Remarks:
This constructor is never used explicitly, but only inside FaceAttribute::create.

virtual NVSG_API ~FaceAttribute ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the FaceAttribute is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const FaceAttribute* create ( ) [static]

Create a FaceAttribute.

Returns:
A pointer to a constant FaceAttribute.
Remarks:
A FaceAttribute with back face culling on, front face culling off, disabled polygon mode, and single sided lighting is created.

NVSG_API const FaceAttribute* createFromBase ( const PrimitiveAttribute & rhs ) [static]

Create a FaceAttribute by copying from a PrimitiveAttribute.

Parameters:
rhs A reference to the constant PrimitiveAttribute to copy from
Returns:
A pointer to a constant FaceAttribute
Remarks:
All the data from the PrimitiveAttribute rhs is used as the base information for the newly created FaceAttribute. FaceAttribute specific data is initialized as if FaceAttribute::create would have been called.
See also:
PrimitiveAttribute

virtual NVSG_API const FaceAttribute* clone ( ) const [virtual]

Create a new FaceAttribute by copying from this.

Returns:
A pointer to a constant FaceAttribute.
Remarks:
The newly created FaceAttribute is an exact copy of this.

Implements StateAttribute.

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 Fri Aug 4 08:37:49 2006 for NVSGSDK by NVIDIA


Member List

FaceAttribute Member List

This is the complete list of members for FaceAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | FaceAttribute | [virtual]
create() | FaceAttribute | [static]
createFromBase(const PrimitiveAttribute &rhs) | FaceAttribute | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
FaceAttribute() | FaceAttribute | [protected]
FaceAttribute(const PrimitiveAttribute &rhs) | FaceAttribute | [explicit, protected]
FaceAttribute(const FaceAttribute &rhs) | FaceAttribute | [protected]
getBackFaceMode() const | FaceAttribute | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFrontFaceMode() const | FaceAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
getPolygonOffsetFactor() const | FaceAttribute | [inline]
getPolygonOffsetUnits() const | FaceAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, 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]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
isTwoSidedLighting() const | FaceAttribute | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const FaceAttribute &rhs) | FaceAttribute |
nvsg::PrimitiveAttribute::operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
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]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~FaceAttribute() | FaceAttribute | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveAttribute() | PrimitiveAttribute | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:37:49 2006 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 Fri Aug 4 08:40:08 2006 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 Fri Aug 4 08:40:08 2006 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 (size_t screenSizeX=1280, size_t 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.

NVSG_API bool | isFly ()
Test if the Manipulator is in fly 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 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 | ( | size_t | screenSizeX = 1280,
 |  | size_t | 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.

NVSG_API bool isFly ( )

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)

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

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 Fri Aug 4 08:39:55 2006 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(size_t screenSizeX=1280, size_t screenSizeY=1024) | FlightCameraManipulator |
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 |
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 Fri Aug 4 08:39:55 2006 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

virtual const FramedAnimation<
T > * 		clone () const
Create a new FramedAnimation of type T by copying from this.

virtual size_t | getNumberOfFrames () const
Get the number of frames.

void | setNumberOfFrames (size_t nof)
Set the number of frames.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other FramedAnimation of type T.

virtual const T & | operator[] (size_t i) const
Constant random access operator.

T & | operator[] (size_t i)
Random access operator.

FramedAnimation< T > & | operator= (const FramedAnimation< T > &rhs)
Assignment operator.

Static Public Member Functions

const FramedAnimation< T > * | create ()
Create a FramedAnimation of type T.

const FramedAnimation< T > * | createFromBase (const Animation< T > &rhs)
Create a FramedAnimation of type T by copying from an Animation of type T.

Protected Member Functions

NVSG_API | FramedAnimation ()
Protected constructor to prevent explicit creation.

NVSG_API | FramedAnimation (const Animation< T > &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | FramedAnimation (const FramedAnimation< T > &rhs)
Protected copy constructor to prevent explicit creation.

virtual | ~FramedAnimation ()
Protected destructor to prevent explicit creation.

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

NVSG_API FramedAnimation ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside FramedAnimation<T>::create.

NVSG_API FramedAnimation ( const Animation< T > & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Animation of type T to use as a base of the new FramedAnimation of type T.
Remarks:
This constructor is never used explicitly, but only inside FramedAnimation<T>::createFromBase.
See also:
Animation

NVSG_API FramedAnimation ( const FramedAnimation< T > & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant FramedAnimation of type T to copy from.
Remarks:
This constructor is never used explicitly, but only inside FramedAnimation<T>::create.

virtual ~FramedAnimation ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the FramedAnimation of type T is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

const FramedAnimation< T > * create ( ) [static]

Create a FramedAnimation of type T.

Returns:
A pointer to a constant FramedAnimation of type T.
Remarks:
Per default, a FramedAnimation starts without Animation data.

const FramedAnimation< T > * createFromBase ( const Animation< T > & rhs ) [static]

Create a FramedAnimation of type T by copying from an Animation of type T.

Parameters:
rhs A reference to the constant Animation of type T to copy from.
Returns:
A pointer to a constant FramedAnimation of type T.
Remarks:
All the data from the Animation of type T rhs is used as the base information for the newly created FramedAnimation of type T. Data specific to a FramedAnimation of type T is initialized as if FramedAnimation<T>::create would have been called.
See also:
Animation

const FramedAnimation< T > * clone ( ) const [virtual]

Create a new FramedAnimation of type T by copying from this.

Returns:
A pointer to a constant FramedAnimation of type T.
Remarks:
The newly created FramedAnimation of type T is an exact copy of this.

Implements Animation.

virtual size_t getNumberOfFrames ( ) const [virtual]

Get the number of frames.

Returns:
The number of frames
Remarks:
The number of frame equals the size of the vector of values of type T held by this FramedAnimation of type T.
See also:
setNumberOfFrames

Implements Animation.

void setNumberOfFrames ( size_t nof )

Set the number of frames.

Parameters:
nof Number of Frames to set.
Remarks:
Setting the number of frames resizes the vector of values of type T. Thus, the constructor of T is called for each new element.
The nvutil::Incarnation is increased.
See also:
getNumberOfFrames

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [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 Object.

virtual const T& operator[] ( size_t i ) const [virtual]

Constant random access operator.

Parameters:
i Index of the frame to access.
Returns:
A reference to the constant value of frame i.
Remarks:
This operator can be used for easy read access to the values for each frame.
Note:
The behavior is undefined if i is larger than or equal to the number of frames.
See also:
getNumberOfFrames, setNumberOfFrames

Implements Animation.

T & operator[] ( size_t i )

Random access operator.

Parameters:
i Index of the frame to access.
Returns:
A reference to the value of frame i.
Remarks:
This random access operator can be used for easy write access to the values for each frame.
The nvutil::Incarnation is increased.
Note:
The behavior is undefined if i is larger than or equal to the number of frames.
See also:
getNumberOfFrames, setNumberOfFrames

FramedAnimation<T>& operator= ( const FramedAnimation< T > & rhs )

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 Fri Aug 4 08:37:50 2006 for NVSGSDK by NVIDIA


Member List

FramedAnimation Member List

This is the complete list of members for FramedAnimation, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
Animation(void) | Animation | [protected]
clone() const | FramedAnimation | [virtual]
create() | FramedAnimation | [static]
createFromBase(const Animation< T > &rhs) | FramedAnimation | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
FramedAnimation() | FramedAnimation | [protected]
FramedAnimation(const Animation< T > &rhs) | FramedAnimation | [explicit, protected]
FramedAnimation(const FramedAnimation< T > &rhs) | FramedAnimation | [protected]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames() const | FramedAnimation | [virtual]
getObjectCode() const | Object | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | FramedAnimation | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const FramedAnimation< T > &rhs) | FramedAnimation |
nvsg::Animation::operator=(const Animation< T > &rhs) | Animation | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
operator[](size_t i) const | FramedAnimation | [virtual]
operator[](size_t i) | FramedAnimation |
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setNumberOfFrames(size_t nof) | FramedAnimation |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Animation(void) | Animation | [protected, virtual]
~FramedAnimation() | FramedAnimation | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:50 2006 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 bool | preTraverseRoot (const nvsg::Camera *p, const nvsg::Node *root)
Re-implementation of the preTraverseRoot method.

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 nvsg::Drawable *p) const
Re-implementation of the cullCode method on a nvsg::Drawable.

virtual NVSG_API nvsg::CullCode | cullCode (const nvsg::Node *p) const
Re-implementation of the cullCode method on a nvsg::Node.

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 bool preTraverseRoot | ( | const nvsg::Camera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Re-implementation of the preTraverseRoot method.

Parameters:
p | A pointer to the constant nvsg::Camera to use on traversal.
root | A pointer to the constant root of the tree.
Returns:
true, if the scene can be traversed, otherwise false.
Remarks:
This method stores the Camera for usage in the CullCode calculations and then returns the result of CullTraverser::preTraverseRoot().
See also:
Traverser

Reimplemented from ModelViewTraverser.

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 ModelViewTraverser.

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 ModelViewTraverser.

virtual NVSG_API nvsg::CullCode cullCode ( const nvsg::Drawable * p ) const [protected, virtual]

Re-implementation of the cullCode method on a nvsg::Drawable.

Parameters:
p A pointer to the constant nvsg::Drawable to determine the nvsg::CullCode of.
Returns:
The nvsg::CullCode of the nvsg::Drawable p relative to the view frustum.
Note:
If the bounding sphere of the nvsg::Drawable p is empty, it is considered to be in.
See also:
CullTraverser

Reimplemented from CullTraverser.

virtual NVSG_API nvsg::CullCode cullCode ( const nvsg::Node * p ) const [protected, virtual]

Re-implementation of the cullCode method on a nvsg::Node.

Parameters:
p A pointer to the constant nvsg::Node to determine the nvsg::CullCode of.
Returns:
The nvsg::CullCode of the nvsg::Node p relative to the view frustum.
Note:
If the bounding sphere of the nvsg::Node p 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 Fri Aug 4 08:39:13 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
cullCode(const nvsg::Drawable *p) const | FrustumCullTraverser | [protected, virtual]
cullCode(const nvsg::Node *p) const | FrustumCullTraverser | [protected, virtual]
CullTraverser() | CullTraverser | [protected]
doApply(const nvsg::Scene *scene) | CullTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
FrustumCullTraverser(void) | FrustumCullTraverser |
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | ModelViewTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | CullTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | CullTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | CullTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | CullTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | CullTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | CullTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | FrustumCullTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | FrustumCullTraverser | [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]
setViewState(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | CullTraverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | CullTraverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~CullTraverser(void) | CullTraverser | [protected, virtual]
~FrustumCullTraverser(void) | FrustumCullTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:13 2006 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 Fri Aug 4 08:36:30 2006 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 Fri Aug 4 08:36:30 2006 for NVSGSDK by NVIDIA


GeoNode Class Reference

Class to hold a set of geometries. More...

#include <GeoNode.h>

Inheritance diagram for GeoNode:

[legend]
Collaboration diagram for GeoNode:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API GeoNode * | clone () const
Create a new GeoNode by copying from this.

NVSG_API size_t | getNumberOfGeometries () const
Get the number of contained geometries.

NVSG_API size_t | getGeometryIndex (const Drawable *drawable) const
Get the index of the geometry holding the specified Drawable.

NVSG_API size_t | getGeometryIndex (const StateSet *stateSet) const
Get the index of the geometry holding the specified StateSet.

NVSG_API void | addGeometry (const Drawable *drawable, const StateSet *stateSet=NULL)
Add a geometry to the GeoNode.

NVSG_API void | removeGeometry (const StateSet *stateSet)
Remove a geometry from the GeoNode.

NVSG_API void | removeGeometry (const Drawable *drawable)
Remove a geometry from the GeoNode.

NVSG_API void | clearGeometries ()
Remove all geometries form the GeoNode.

NVSG_API const StateSet * | getStateSet (size_t geometryIndex) const
Get the StateSet of the specified geometry.

NVSG_API const StateSet * | getStateSet (const Drawable *drawable) const
Get the StateSet associated with a specified Drawable.

NVSG_API void | replaceStateSet (const StateSet *newStateSet, const StateSet *oldStateSet)
Replace a StateSet by another.

NVSG_API size_t | getNumberOfDrawables (size_t geometryIndex) const
Get the number of Drawable objects of the specified Geometry.

NVSG_API const Drawable * | getDrawable (size_t geometryIndex, size_t drawableIndex) const
Get the Drawable at the specified index of the specified Geometry.

NVSG_API void | replaceDrawable (const Drawable *newDrawable, const Drawable *oldDrawable, const StateSet *stateSet)
Replace a Drawable by another.

NVSG_API void | replaceDrawable (const Drawable *newDrawable, const Drawable *oldDrawable)
Replace a Drawable by another.

NVSG_API void | clearTexCoords (size_t tu=0)
Clear texture coordinates on all Drawable objects.

virtual NVSG_API bool | containsCgFx () const
Query if this GeoNode contains any CgFx StateAttribute.

virtual NVSG_API void | invalidateCgFxContainment ()
Invalidate the CgFx containment cache.

virtual NVSG_API size_t | getNumberOfFrames () const
Query the number of frames in the Animation objects in this GeoNode.

virtual NVSG_API void | invalidateNumberOfFrames () const
Invalidate the number of animation frames cache.

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.

Static Public Member Functions

NVSG_API const GeoNode * | create ()
Create a GeoNode.

NVSG_API const GeoNode * | createFromBase (const Node &rhs)
Create a GeoNode by copying from a Node.

Protected Member Functions

NVSG_API | GeoNode ()
Protected constructor to prevent explicit creation.

NVSG_API | GeoNode (const Node &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | GeoNode (const GeoNode &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~GeoNode ()
Protected destructor to prevent explicit creation.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this GeoNode.

virtual NVSG_API bool | determineTransparencyContainment () const
Determine the transparency containment state.

NVSG_API void | invalidateCaches (const StateSet *stateSet, bool insert)
Invalidate all caches of this GeoNode.

virtual NVSG_API void | validateIncarnation () const
Validate the nvutil::Incarnation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const GeoNode *gn, size_t tu=0, size_t tg=1, size_t 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 (const GeoNode *gn)
Generate normals for all QuadMeshes, Quads, QuadStrip, Triangles, TriFans, and TriStrip in a GeoNode.

NVSG_API void | generateTexCoords (const GeoNode *gn, TextureCoordType tct, size_t tu=0, bool overwrite=true)
Generate texture coordinates on all Drawable objects.

Detailed Description

Class to hold a set of geometries.

Namespace: nvsg
Remarks:
A GeoNode in a scene graph is always a leaf node. It holds a number of Drawable objects, each one associated to a StateSet. For performance reasons, Drawable objects associated to the same StateSet, together with that StateSet, are logically gathered to one element of a so-called Geometry. Thus, iterating over all Drawable objects is a two-level process; on the outer loop iterating over all Geometries, and on the inner loop iterating over all Drawable objects associated to the StateSet of that Geometry. There cannot be the same Drawable more than once in a GeoNode.
See also:
Drawable, Node, Scene, StateSet

Constructor & Destructor Documentation

NVSG_API GeoNode ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside GeoNode::create.

NVSG_API GeoNode ( const Node & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Node to use as a base of the new GeoNode.
Remarks:
This constructor is never used explicitly, but only inside GeoNode::createFromBase.
See also:
Node

NVSG_API GeoNode ( const GeoNode & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant GeoNode to copy from.
Remarks:
This constructor is never used explicitly, but only inside GeoNode::create.

virtual NVSG_API ~GeoNode ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the GeoNode is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const GeoNode* create ( ) [static]

Create a GeoNode.

Returns:
A pointer to a constant GeoNode.
Remarks:
Per default, a GeoNode does not hold any geometries.

NVSG_API const GeoNode* createFromBase ( const Node & rhs ) [static]

Create a GeoNode by copying from a Node.

Parameters:
rhs A reference to the constant Node to copy from.
Returns:
A pointer to a constant GeoNode.
Remarks:
All the data from the Node rhs is used as the base information for the newly created GeoNode. Data specific to a GeoNode is initialized as if GeoNode::create would have been called.
See also:
Node

virtual NVSG_API GeoNode* clone ( ) const [virtual]

Create a new GeoNode by copying from this.

Returns:
A pointer to a constant GeoNode.
Remarks:
The newly created GeoNode is an exact copy of this.

Implements Node.

size_t getNumberOfGeometries ( ) const [inline]

Get the number of contained geometries.

Returns:
The number of contained geometries.
Remarks:
A geometry is defined by a pointer to a constant StateSet, which might be the NULL pointer, and a number of pointers to constant Drawable objects associated with that StateSet.
See also:
Drawable, StateSet

NVSG_API size_t getGeometryIndex ( const Drawable * drawable ) const

Get the index of the geometry holding the specified Drawable.

Parameters:
drawable A pointer to the constant Drawable, for which the geometry index is queried.
Returns:
The index of the Geometry holding the Drawable drawable, or (-1) if drawable is not part of any Geometry of this GeoNode.
See also:
Drawable, getNumberOfGeometries, getStateSet

NVSG_API size_t getGeometryIndex ( const StateSet * stateSet ) const

Get the index of the geometry holding the specified StateSet.

Parameters:
stateSet A pointer to the constant StateSet, for which the geometry index is queried.
Returns:
The index of the Geometry associated with the StateSet stateSet, or (-1) if stateSet is not part of any Geometry of this GeoNode.
See also:
Drawable, getNumberOfGeometries, getStateSet

NVSG_API void addGeometry | ( | const Drawable * | drawable,
 |  | const StateSet * | stateSet = NULL
 | ) |

Add a geometry to the GeoNode.

Parameters:
drawable | A pointer to the constant Drawable to add.
stateSet | An optional pointer to a constant StateSet. The default is NULL.
Remarks:
The Drawable drawable is added to the Geometry associated with the StateSet stateSet. On adding, the reference count of drawable is incremented. If there was no Geometry associated with stateSet, a new one is created and the reference count of stateSet is incremented.
The nvutil::Incarnation is increased.
Note:
The behavior is undefined if drawable is not a valid pointer.
See also:
Drawable, StateSet

NVSG_API void removeGeometry ( const StateSet * stateSet )

Remove a geometry from the GeoNode.

Parameters:
stateSet A pointer to a constant StateSet to remove.
Remarks:
The Geometry associated with the StateSet stateSet is removed. On removal, the reference count of each Drawable assigned to stateSet, as well as the reference count of stateSet, if it is not NULL, is decremented.
The nvutil::Incarnation is increased.
See also:
Drawable, StateSet

NVSG_API void removeGeometry ( const Drawable * drawable )

Remove a geometry from the GeoNode.

Parameters:
drawable A Drawable to remove.
Remarks:
The Drawable drawable is removed from the Geometries of this GeoNode. If a Geometry of this GeoNode has the Drawable drawable assigned, the reference count of drawable is decremented and it is removed from the Geometry. If it was the only Drawable in that Geometry, the Geometry is removed from the GeoNode and, if the associated StateSet is not NULL, its reference count is also decremented.
The nvutil::Incarnation is increased.
Note:
The behavior is undefined if drawable is NULL.
See also:
Drawable, StateSet

NVSG_API void clearGeometries ( )

Remove all geometries form the GeoNode.

Remarks:
The reference count of all Drawable objects and all StateSet objects held by this GeoNode is decremented, and the Geometries are cleared.
The nvutil::Incarnation is increased.
See also:
Drawable, StateSet

const StateSet * getStateSet ( size_t geometryIndex ) const [inline]

Get the StateSet of the specified geometry.

Parameters:
geometryIndex The index of the geometry to get information.
Returns:
A pointer to the constant StateSet at position geometryIndex in this GeoNode.
Remarks:
If the Geometry with index geometryIndex has no StateSet bound, NULL is returned.
Note:
The behavior is undefined, if geometryIndex is larger than or equal to the number of geometries of this GeoNode.
See also:
StateSet, getNumberOfGeometries

const StateSet * getStateSet ( const Drawable * drawable ) const [inline]

Get the StateSet associated with a specified Drawable.

Parameters:
drawable A pointer to the constant Drawable for which to query the StateSet.
Returns:
A pointer to the constant StateSet that drawable is associated with.
Remarks:
If there is no StateSet associated to the Drawable drawable, NULL is returned.
Note:
The behavior is undefined if drawable is not a valid pointer, or if drawable is not part of any Geometry of this GeoNode.
See also:
Drawable, StateSet, getGeometryIndex

NVSG_API void replaceStateSet | ( | const StateSet * | newStateSet,
 |  | const StateSet * | oldStateSet
 | ) |

Replace a StateSet by another.

Parameters:
newStateSet | A pointer to the constant StateSet that replaces oldStateSet.
oldStateSet | A pointer to the constant StateSet that is replaced by newStateSet.
Remarks:
All Drawable objects that are associated to oldStateSet are changed to be associated with newStateSet. If oldStateSet is a valid pointer, its reference count is decreased; and if newStateSet is a valid pointer, its reference count is increased.
The nvutil::Incarnation is increased.
See also:
Drawable, StateSet

size_t getNumberOfDrawables ( size_t geometryIndex ) const [inline]

Get the number of Drawable objects of the specified Geometry.

Parameters:
geometryIndex The index of the Geometry to use.
Returns:
The number of Drawable objects in the Geometry at position geometryIndex.
Note:
The behavior is undefined if geometryIndex is larger than or equal to the number of Geometries of this GeoNode.
See also:
Drawable, getGeometryIndex

const Drawable * getDrawable | ( | size_t | geometryIndex,
 |  | size_t | drawableIndex
 | ) | const [inline]

Get the Drawable at the specified index of the specified Geometry.

Parameters:
geometryIndex | The index of the Geometry to use
drawableIndex | The index of the Drawable to get
Returns:
A pointer to the constant Drawable at the specified position.
Note:
The behavior is undefined if geometryIndex is larger than or equal to the number of Geometries of this GeoNode, or if drawableIndex is large than or equal to the number of Drawable objects in that Geometry.
See also:
Drawable, getNumberOfGeometries, getNumberOfDrawables

NVSG_API void replaceDrawable | ( | const Drawable * | newDrawable,
 |  | const Drawable * | oldDrawable,
 |  | const StateSet * | stateSet
 | ) |

Replace a Drawable by another.

Parameters:
newDrawable | A pointer to the constant Drawable that replaces oldDrawable.
oldDrawable | A pointer to the constant Drawable that is replaced by newDrawable.
stateSet | A pointer to the constant StateSet, that oldDrawable is associated with.
Remarks:
In the Geometry defined by stateSet, the Drawable oldDrawable is replaced with newDrawable. On replacing, the reference count of newDrawable is incremented, the reference count of oldDrawable is decremented, and the nvutil::Incarnation is increased.
See also:
Drawable, StateSet

NVSG_API void replaceDrawable | ( | const Drawable * | newDrawable,
 |  | const Drawable * | oldDrawable
 | ) |

Replace a Drawable by another.

Parameters:
newDrawable | A pointer to the constant Drawable that replaces oldDrawable.
oldDrawable | A pointer to the constant Drawable that is replaced by newDrawable.
Remarks:
The Drawable oldDrawable is replaced by newDrawable, no matter to what StateSet oldDrawable is associated with. On replacing, the reference count of newDrawable is increased, the reference count of oldDrawable is decreased, and the nvutil::Incarnation is increased.
See also:
Drawable

NVSG_API void clearTexCoords ( size_t tu = 0 )

Clear texture coordinates on all Drawable objects.

virtual NVSG_API bool containsCgFx ( ) const [virtual]

Query if this GeoNode contains any CgFx StateAttribute.

Returns:
true if this GeoNode holds at least one StateSet with a CgFx, otherwise false.
Remarks:
Because a CgFx does not use the standard drawing pipeline, it might be of interest in several cases to know if there is a CgFx contained in a GeoNode.
See also:
CgFx, StateAttribute

Reimplemented from Node.

virtual NVSG_API void invalidateCgFxContainment ( ) [virtual]

Invalidate the CgFx containment cache.

Remarks:
Invalidating the CgFx containment cache marks this information as invalid and reports the change to all its owners.
See also:
CgFx, StateAttribute

Reimplemented from Node.

virtual NVSG_API size_t getNumberOfFrames ( ) const [virtual]

Query the number of frames in the Animation objects in this GeoNode.

Returns:
The number of frames in the Animation objects in this GeoNode.
Remarks:
If there is no Animation part of this GeoNode, the number of frames returned is zero.
Note:
Currently, all Animations in a Scene must have the same number of frames.
See also:
Animation

Reimplemented from Node.

virtual NVSG_API void invalidateNumberOfFrames ( ) const [virtual]

Invalidate the number of animation frames cache.

Remarks:
Invalidating the number of animation frames cache marks this information as invalid and reports the change to all its owners.
See also:
Animation

Reimplemented from Node.

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 nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this GeoNode.

Returns:
A nvmath::Sphere3f 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, invalidateBoundingSphere

Implements Node.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, virtual]

Determine the transparency containment state.

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.

NVSG_API void invalidateCaches | ( | const StateSet * | stateSet,
 |  | bool | insert
 | ) | [protected]

Invalidate all caches of this GeoNode.

Parameters:
stateSet | A pointer to the constant StateSet that has been added or removed.
insert | true, if stateSet has been added, otherwise false.
Remarks:
This function is called by the framework whenever a StateSet has been to added or removed from this GeoNode. Depending on the resulting changes, the specific cache invalidation functions are then called.
See also:
StateSet, invalidateCgFxContainment, invalidateTransparencyContainment

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 Object.

Friends And Related Function Documentation

NVSG_API void calculateTangentSpace | ( | const GeoNode * | gn,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | 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 ( const 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 | ( | const GeoNode * | gn,
 |  | TextureCoordType | tct,
 |  | size_t | 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 Fri Aug 4 08:37:52 2006 for NVSGSDK by NVIDIA


Member List

GeoNode Member List

This is the complete list of members for GeoNode, including all inherited members.
addGeometry(const Drawable *drawable, const StateSet *stateSet=NULL) | GeoNode |
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | GeoNode | [protected, virtual]
calculateTangentSpace(const GeoNode *gn, size_t tu=0, size_t tg=1, size_t bn=2, bool overwrite=true) | GeoNode | [related]
clearGeometries() | GeoNode |
clearTexCoords(size_t tu=0) | GeoNode |
clone() const | GeoNode | [virtual]
containsCgFx() const | GeoNode | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Node | [virtual]
containsTransparentGeometry() const | Node |
create() | GeoNode | [static]
createFromBase(const Node &rhs) | GeoNode | [static]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineTransparencyContainment() const | GeoNode | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
generateNormals(const GeoNode *gn) | GeoNode | [related]
generateTexCoords(const GeoNode *gn, TextureCoordType tct, size_t tu=0, bool overwrite=true) | GeoNode | [related]
GeoNode() | GeoNode | [protected]
GeoNode(const Node &rhs) | GeoNode | [explicit, protected]
GeoNode(const GeoNode &rhs) | GeoNode | [protected]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDrawable(size_t geometryIndex, size_t drawableIndex) const | GeoNode | [inline]
getGeometryIndex(const Drawable *drawable) const | GeoNode |
getGeometryIndex(const StateSet *stateSet) const | GeoNode |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfDrawables(size_t geometryIndex) const | GeoNode | [inline]
getNumberOfFrames() const | GeoNode | [virtual]
getNumberOfGeometries() const | GeoNode | [inline]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getStateSet(size_t geometryIndex) const | GeoNode | [inline]
getStateSet(const Drawable *drawable) const | GeoNode | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const StateSet *stateSet, bool insert) | GeoNode | [protected]
invalidateCgFxContainment() | GeoNode | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Node | [virtual]
invalidateNumberOfFrames() const | GeoNode | [virtual]
invalidateTransparencyContainment() | Node |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | GeoNode | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const GeoNode &rhs) | GeoNode |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeGeometry(const StateSet *stateSet) | GeoNode |
removeGeometry(const Drawable *drawable) | GeoNode |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceDrawable(const Drawable *newDrawable, const Drawable *oldDrawable, const StateSet *stateSet) | GeoNode |
replaceDrawable(const Drawable *newDrawable, const Drawable *oldDrawable) | GeoNode |
replaceStateSet(const StateSet *newStateSet, const StateSet *oldStateSet) | GeoNode |
setAnnotation(const std::string &anno) | Node |
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | GeoNode | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~GeoNode() | GeoNode | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:52 2006 for NVSGSDK by NVIDIA


GeoNodeCombineTraverser Class Reference

Traverser that combines multiple GeoNodes under one Group to a single one. More...

#include <GeoNodeCombineTraverser.h>

Inheritance diagram for GeoNodeCombineTraverser:

[legend]
Collaboration diagram for GeoNodeCombineTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | GeoNodeCombineTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~GeoNodeCombineTraverser (void)
Protected destructor to prevent instantiation of a GeoNodeCombineTraverser on stack.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Combine all GeoNodes directly underneath this AnimatedTransform.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Combine all GeoNodes directly underneath this Billboard.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Combine all GeoNodes directly underneath this Group.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Combine all GeoNodes directly underneath this Transform.

Detailed Description

Traverser that combines multiple GeoNodes under one Group to a single one.

All geometries of all GeoNodes under one Group are reparented to a single GeoNode.

Constructor & Destructor Documentation

NVSG_API GeoNodeCombineTraverser ( void )

Constructor.

virtual NVSG_API ~GeoNodeCombineTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a GeoNodeCombineTraverser on stack.

Member Function Documentation

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Combine all GeoNodes directly underneath this AnimatedTransform.

Parameters:
p currently visited AnimatedTransform.

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Combine all GeoNodes directly underneath this Billboard.

Parameters:
p Points to the currently visited Billboard object.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Combine all GeoNodes directly underneath this Group.

Parameters:
p Points to the currently visited Group object.

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Combine all GeoNodes directly underneath this Transform.

Parameters:
p Points to the currently visited Transform object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • GeoNodeCombineTraverser.h
Generated on Fri Aug 4 08:39:14 2006 for NVSGSDK by NVIDIA


Member List

GeoNodeCombineTraverser Member List

This is the complete list of members for GeoNodeCombineTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | OptimizeTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
GeoNodeCombineTraverser(void) | GeoNodeCombineTraverser |
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | GeoNodeCombineTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | GeoNodeCombineTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | GeoNodeCombineTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | GeoNodeCombineTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~GeoNodeCombineTraverser(void) | GeoNodeCombineTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:14 2006 for NVSGSDK by NVIDIA


GeoNodeUnifyTraverser Class Reference

Optimizing Traverser that unifies GeoNodes. More...

#include <GeoNodeUnifyTraverser.h>

Inheritance diagram for GeoNodeUnifyTraverser:

[legend]
Collaboration diagram for GeoNodeUnifyTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | GeoNodeUnifyTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~GeoNodeUnifyTraverser (void)
Protected destructor to prevent instantiation of a GeoNodeCombineTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *pScene)
clear temporary storage after traversing

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Routine to handle a AnimatedTransform node while traversing the scene graph.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Routine to handle a Billboard node 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 | 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.

Detailed Description

Optimizing Traverser that unifies GeoNodes.

Maps identical GeoNodes to the same one.

Constructor & Destructor Documentation

NVSG_API GeoNodeUnifyTraverser ( void )

Constructor.

virtual NVSG_API ~GeoNodeUnifyTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a GeoNodeCombineTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * pScene ) [protected, virtual]

clear temporary storage after traversing

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Routine to handle a AnimatedTransform node while traversing the scene graph.

This routine gets called for each AnimatedTransform object that will be visited while traversing the scene graph. The currently visited AnimatedTransform object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Routine to handle a Billboard node while traversing the scene graph.

This routine gets called for each Billboard object that will be visited while traversing the scene graph. The currently visited Billboard object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Routine to handle a Group node while traversing the scene graph.

This routine gets called for each Group object that will be visited while traversing the scene graph. The currently visited Group object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

During child traversal you must not change the number or the position of children. Overload and use postTraverseGroup() for this.

Reimplemented from Traverser.

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.

This routine gets called for each LOD object that will be visited while traversing the scene graph. The currently visited LOD object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Routine to handle a Switch node while traversing the scene graph.

This routine gets called for each Switch object that will be visited while traversing the scene graph. The currently visited Switch object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Routine to handle a Transform node while traversing the scene graph.

This routine gets called for each Transform object that will be visited while traversing the scene graph. The currently visited Transform object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • GeoNodeUnifyTraverser.h
Generated on Fri Aug 4 08:39:15 2006 for NVSGSDK by NVIDIA


Member List

GeoNodeUnifyTraverser Member List

This is the complete list of members for GeoNodeUnifyTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *pScene) | GeoNodeUnifyTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
GeoNodeUnifyTraverser(void) | GeoNodeUnifyTraverser |
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | GeoNodeUnifyTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | GeoNodeUnifyTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | GeoNodeUnifyTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | GeoNodeUnifyTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | GeoNodeUnifyTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | GeoNodeUnifyTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~GeoNodeUnifyTraverser(void) | GeoNodeUnifyTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:15 2006 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 ()

Friends

NVSG_API void | GLAccum (GLenum op, GLfloat value)
Replacement of glAccum.

NVSG_API void | GLActiveTexture (GLenum texture)
Replacement of glActiveTexture.

NVSG_API void | GLAlphaFunc (GLenum func, GLclampf ref)
Replacement of glAlphaFunc.

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 | 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 glBeginQueryARB.

NVSG_API void | GLBindBuffer (GLenum target, GLuint id)
Replacement of glBindBufferARB.

NVSG_API void | GLBindProgram (GLenum target, GLuint id)
Replacement of glBindProgramNV.

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 | GLBindTexture (GLenum target, GLuint texture)
Replacement of glBindTexture.

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 | GLBufferData (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage)
Replacement of glBufferDataARB.

NVSG_API void | GLBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data)
Replacement of glBufferSubDataARB.

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 | 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 | GLClearDepth (GLclampd depth)
Replacement of glClearDepth.

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 | 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 | 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 | 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 | 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 | 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 | GLCullFace (GLenum mode)
Replacement of glCullFace.

NVSG_API void | GLCullFaceLock (GLenum mode)
NVSG_API void | GLCullFaceUnlock (GLenum mode)
NVSG_API void | GLDeleteBuffers (GLsizei n, const GLuint *buffers)
Replacement of glDeleteBuffersARB.

NVSG_API void | GLDeleteLists (GLuint list, GLsizei range)
Replacement of glDeleteLists.

NVSG_API void | GLDeleteOcclusionQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteOcclusionQueriesNV.

NVSG_API void | GLDeletePrograms (GLsizei n, const GLuint *ids)
Replacement of glDeleteProgramsNV.

NVSG_API void | GLDeleteQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteQueriesARB.

NVSG_API void | GLDeleteTextures (GLsizei n, const GLuint *textures)
Replacement of glDeleteTextures.

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 | GLDisable (GLenum cap)
Replacement of glDisable.

NVSG_API void | GLDisableBlend (void)
Cached version of GLDisable( GL_BLEND ).

NVSG_API void | GLDisableClientState (GLenum array)
Replacement of glDisableClientState.

NVSG_API void | GLDisableColorArray (void)
Cached version of GLDisableClientState( GL_COLOR_ARRAY ).

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)
NVSG_API void | GLDisableCullFaceUnlock (void)
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 | GLDisableLighting (void)
Cached version of GLDisable( GL_LIGHTING ).

NVSG_API void | GLDisableLightingLock (void)
NVSG_API void | GLDisableLightingUnlock (void)
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 | GLDisableNormalize (void)
Cached version of GLDisable( GL_NORMALIZE ).

NVSG_API void | GLDisablePointSmooth (void)
Cached version of GLEnable( 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 | GLDisablePolygonStipple (void)
Cached version of GLDisable( GL_POLYGON_STIPPLE ).

NVSG_API void | GLDisableSecondaryColorArray (void)
Cached version of GLDisableClientState( GL_SECONDARY_COLOR_ARRAY ).

NVSG_API void | GLDisableTexture (GLenum target)
Cached version of GLDisable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 | GLDrawArrays (GLenum mode, GLint first, GLsizei count)
Replacement of glDrawArrays.

NVSG_API void | GLDrawBuffer (GLenum mode)
Replacement of glDrawBuffer.

NVSG_API void | GLDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
Replacement of glDrawElements.

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 | GLEnableBlend (void)
Cached version of GLEnable( GL_BLEND ).

NVSG_API void | GLEnableClientState (GLenum array)
Replacement of glEnableClientState.

NVSG_API void | GLEnableColorArray (void)
Cached version of GLEnableClientState( GL_COLOR_ARRAY ).

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)
NVSG_API void | GLEnableCullFaceUnlock (void)
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 | 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 | 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 | GLEnablePolygonStipple (void)
Cached version of GLEnable( GL_POLYGON_STIPPLE ).

NVSG_API void | GLEnableSecondaryColorArray (void)
Cached version of GLEnableClientState( GL_SECONDARY_COLOR_ARRAY ).

NVSG_API void | GLEnableTexture (GLenum target)
Cached version of GLEnable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 | 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 glEndQueryARB.

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 | GLFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)
Replacement of glFeedbackBuffer.

NVSG_API void | GLFinish (void)
Replacement of glFinish.

NVSG_API void | GLFlush (void)
Replacement of glFlush.

NVSG_API void | GLFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glFogCoordPointer.

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 | 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 | GLGenBuffers (GLsizei n, GLuint *buffers)
Replacement of glGenBuffersARB.

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 glGenQueriesARB.

NVSG_API void | GLGenTextures (GLsizei n, GLuint *textures)
Replacement of glGenTextures.

NVSG_API void | GLGetBooleanv (GLenum pname, GLboolean *params)
Replacement of glGetBooleanv.

NVSG_API void | GLGetDoublev (GLenum pname, GLdouble *params)
Replacement of glGetDoublev.

NVSG_API void | GLGetFloatv (GLenum pname, GLfloat *params)
Replacement of glGetFloatv.

NVSG_API void | GLGetIntegerv (GLenum pname, GLint *params)
Replacement of glGetIntegerv.

NVSG_API void | GLGetClipPlane (GLenum plane, GLdouble *equation)
Replacement of glGetClipPlane.

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 | 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 | GLGetQueryiv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetQueryivARB.

NVSG_API void | GLGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
Replacement of glGetQueryObjectivARB.

NVSG_API void | GLGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
Replacement of glGetQueryObjectuivARB.

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 | GLHint (GLenum target, GLenum mode)
Replacement of glHint.

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 | GLIsBuffer (GLuint name)
Replacement of glIsBufferARB.

NVSG_API GLboolean | GLIsEnabled (GLenum cap)
Replacement of glIsEnabled.

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 | GLIsList (GLuint list)
Replacement of glIsList.

NVSG_API GLboolean | GLIsOcclusionQuery (GLuint id)
Replacement of glIsOcclusionQueryNV.

NVSG_API GLboolean | GLIsProgram (GLuint id)
Replacement of glIsProgramNV.

NVSG_API GLboolean | GLIsQuery (GLuint id)
Replacement of glIsQueryARB.

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 | 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 GLLightModelAmbient.

NVSG_API void | GLLightModelLocalViewer (GLint param)
Replacement of GLLightModelLocalViewer.

NVSG_API void | GLLightModelTwoSide (GLint param)
Replacement of GLLightModelTwoSide.

NVSG_API void | GLLightModelTwoSideLock (GLint param)
NVSG_API void | GLLightModelTwoSideUnlock (GLint param)
NVSG_API void | GLLineStipple (GLint factor, GLushort pattern)
Replacement of glLineStipple.

NVSG_API void | GLLineWidth (GLfloat width)
Replacement of glLineWidth.

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 | 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 glMapBufferARB.

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 | GLMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount)
Replacement of glMultiDrawElements.

NVSG_API void | GLMultiTexCoord2f (GLenum texture, GLfloat tx, GLfloat ty)
Replacement of glMultiTexCoord2f.

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 | 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 | 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 | 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)
NVSG_API void | GLPolygonModeUnlock (GLenum face, GLenum mode)
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 | GLPrimitiveRestartIndex (GLuint index)
Replacement of glPrimitiveRestartIndex.

NVSG_API void | GLPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)
Replacement of glPrioritizeTextures.

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 | 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 | 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 | GLScissor (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glScissor.

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 | GLSetWindowStereoMode (GLboolean displayMode)
Replacement of glSetWindowStereoModeNV.

NVSG_API void | GLShadeModel (GLenum mode)
Replacement of glShadeModel.

NVSG_API void | GLStencilFunc (GLenum func, GLint ref, GLuint mask)
Replacement of glStencilFunc.

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 | GLTexCoord1d (GLdouble s)
Replacement of glTexCoord1d.

NVSG_API void | GLTexCoord1f (GLfloat s)
Replacement of glTexCoord1f.

NVSG_API void | GLTexCoord1i (GLint s)
Replacement of glTexCoord1i.

NVSG_API void | GLTexCoord1s (GLshort s)
Replacement of glTexCoord1s.

NVSG_API void | GLTexCoord2d (GLdouble s, GLdouble t)
Replacement of glTexCoord2d.

NVSG_API void | GLTexCoord2f (GLfloat s, GLfloat t)
Replacement of glTexCoord2f.

NVSG_API void | GLTexCoord2fv (const GLfloat *v)
Replacement of glTexCoord2fv.

NVSG_API void | GLTexCoord2i (GLint s, GLint t)
Replacement of glTexCoord2i.

NVSG_API void | GLTexCoord2s (GLshort s, GLshort t)
Replacement of glTexCoord2s.

NVSG_API void | GLTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
Replacement of glTexCoord3d.

NVSG_API void | GLTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
Replacement of glTexCoord3f.

NVSG_API void | GLTexCoord3i (GLint s, GLint t, GLint r)
Replacement of glTexCoord3i.

NVSG_API void | GLTexCoord3s (GLshort s, GLshort t, GLshort r)
Replacement of glTexCoord3s.

NVSG_API void | GLTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Replacement of glTexCoord4d.

NVSG_API void | GLTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Replacement of glTexCoord4f.

NVSG_API void | GLTexCoord4i (GLint s, GLint t, GLint r, GLint q)
Replacement of glTexCoord4i.

NVSG_API void | GLTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
Replacement of glTexCoord4s.

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 | GLTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImate1D.

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 glTexSubImate2D.

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 | 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 GLboolean | GLUnmapBuffer (GLenum target)
Replacement of glUnmapBufferARB.

NVSG_API void | GLVertex2d (GLdouble x, GLdouble y)
Replacement of glVertex2d.

NVSG_API void | GLVertex2f (GLfloat x, GLfloat y)
Replacement of glVertex2f.

NVSG_API void | GLVertex2i (GLint x, GLint y)
Replacement of glVertex2i.

NVSG_API void | GLVertex2s (GLshort x, GLshort y)
Replacement of glVertex2s.

NVSG_API void | GLVertex3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glVertex3d.

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 | GLVertex3i (GLint x, GLint y, GLint z)
Replacement of glVertex3i.

NVSG_API void | GLVertex3s (GLshort x, GLshort y, GLshort z)
Replacement of glVertex3s.

NVSG_API void | GLVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glVertex4d.

NVSG_API void | GLVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glVertex4f.

NVSG_API void | GLVertex4i (GLint x, GLint y, GLint z, GLint w)
Replacement of glVertex4i.

NVSG_API void | GLVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glVertex4s.

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 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 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 void | GLGenDisplayListCache (const nvsg::DALHost *host, GLDisplayListCache *&cache)
NVSG_API void | GLGenArrayBufferCache (const nvsg::DALHost *host, GLArrayBufferCache *&cache)
NVSG_API void | GLGenElementArrayBufferCache (const nvsg::DALHost *host, GLElementArrayBufferCache *&cache)
NVSG_API void | GLGenTextureCache (const nvsg::DALHost *host, GLTextureCache *&cache)
NVSG_API void | GLGenTextureCache (const nvsg::DALHost *host, GLTextureCache *&cache, GLuint texture, GLenum target)

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.

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 GLActiveTexture ( GLenum texture ) [friend]

Replacement of glActiveTexture.

This function stores the texture to activate for subsequent texture operations.

NVSG_API void GLAlphaFunc | ( | GLenum | func,
 |  | GLclampf | ref
 | ) | [friend]

Replacement of glAlphaFunc.

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 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 hides the extension character of glBeginOcclusionQueryNV and asserts on the result before returning.

NVSG_API void GLBeginQuery | ( | GLenum | target,
 |  | GLuint | id
 | ) | [friend]

Replacement of glBeginQueryARB.

This function hides the extension character of glBeginQueryARB and asserts on the result before returning.

NVSG_API void GLBindBuffer | ( | GLenum | target,
 |  | GLuint | id
 | ) | [friend]

Replacement of glBindBufferARB.

This function hides the extension character of glBindBufferARB, caches, and 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 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 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 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 GLBufferData | ( | GLenum | target,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data,
 |  | GLenum | usage
 | ) | [friend]

Replacement of glBufferDataARB.

This function hides the extension character of glBufferDataARB and asserts on the result before returning.

NVSG_API void GLBufferSubData | ( | GLenum | target,
 |  | GLintptrARB | offset,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data
 | ) | [friend]

Replacement of glBufferSubDataARB.

This function hides the extension character of glBufferSubDataARB 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 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 GLClearDepth ( GLclampd depth ) [friend]

Replacement of glClearDepth.

This function clears the depth setting and 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 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 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 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 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 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 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 GLCullFace ( GLenum mode ) [friend]

Replacement of glCullFace.

This function caches the cull face setting and asserts on the result before returning.

NVSG_API void GLDeleteBuffers | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) | [friend]

Replacement of glDeleteBuffersARB.

This function hides the extension character of glDeleteBuffersARB, updates some caches, and asserts on the result before returning.

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 GLDeleteOcclusionQueries | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [friend]

Replacement of glDeleteOcclusionQueriesNV.

This function hides the extension character of glDeleteOcclusionQueriesNV, 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 glDeleteQueriesARB.

This function hides the extension character of glDeleteQueriesARB, updates some caches, and 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 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 GLDisable ( GLenum cap ) [friend]

Replacement of glDisable.

This function caches on some cap values and asserts on the result before returning.

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 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 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 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 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 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 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 GLEnable( 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 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 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 GLDisableTexture ( GLenum target ) [friend]

Cached version of GLDisable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 GLDrawArrays | ( | GLenum | mode,
 |  | GLint | first,
 |  | GLsizei | count
 | ) | [friend]

Replacement of glDrawArrays.

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 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 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 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 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 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 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 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 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 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 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]

Cached version of GLEnable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 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 hides the extension character of glEndOcclusionQueryNV and asserts on the result before returning.

NVSG_API void GLEndQuery ( GLenum target ) [friend]

Replacement of glEndQueryARB.

This function hides the extension character of glEndQueryARB and 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 GLFeedbackBuffer | ( | GLsizei | size,
 |  | GLenum | type,
 |  | GLfloat * | buffer
 | ) | [friend]

Replacement of glFeedbackBuffer.

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 GLFlush ( void ) [friend]

Replacement of glFlush.

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 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 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 GLGenBuffers | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) | [friend]

Replacement of glGenBuffersARB.

This function hides the extension character of glGenBuffersARB, asserts on the result, and updates some caches.

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 hides the extension character of glGenOcclusionQueriesNV and 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 glGenQueriesARB.

This function hides the extension character of glGenQueriesARB and 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 GLGetBooleanv | ( | GLenum | pname,
 |  | GLboolean * | params
 | ) | [friend]

Replacement of glGetBooleanv.

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 GLGetFloatv | ( | GLenum | pname,
 |  | GLfloat * | params
 | ) | [friend]

Replacement of glGetFloatv.

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 GLGetClipPlane | ( | GLenum | plane,
 |  | GLdouble * | equation
 | ) | [friend]

Replacement of glGetClipPlane.

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 GLGetOcclusionQueryuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetOcclusionQueryuivNV.

This function hides the extension character of glGetOcclusionQueryuivNV and 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 GLGetQueryiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetQueryivARB.

This function hides the extension character of glGetQueryivARB and asserts on the result before returning.

NVSG_API void GLGetQueryObjectiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [friend]

Replacement of glGetQueryObjectivARB.

This function hides the extension character of glGetQueryObjectivARB and asserts on the result before returning.

NVSG_API void GLGetQueryObjectuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [friend]

Replacement of glGetQueryObjectuivARB.

This function hides the extension character of glGetQueryObjectuivARB and 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 GLHint | ( | GLenum | target,
 |  | GLenum | mode
 | ) | [friend]

Replacement of glHint.

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 GLIsBuffer ( GLuint name ) [friend]

Replacement of glIsBufferARB.

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 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 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 id ) [friend]

Replacement of glIsProgramNV.

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 glIsQueryARB.

This function tests if for the current context, id denotes a valid query and 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 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 GLLightModelAmbient.

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 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 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 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 glMapBufferARB.

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 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 GLMultiTexCoord2f | ( | GLenum | texture,
 |  | GLfloat | tx,
 |  | GLfloat | ty
 | ) | [friend]

Replacement of glMultiTexCoord2f.

This function hides the extension character of glMultiTexCoord2f and 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 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 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 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 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 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 GLProgramNamedParameter4f | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [friend]

Replacement of glProgramNamedParameter4fNV.

This function hides the extension character of glProgramNamedParameter4fNV and 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 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 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 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 GLSetWindowStereoMode ( GLboolean displayMode ) [friend]

Replacement of glSetWindowStereoModeNV.

This function hides the extension character of glSetWindowStereoModeNV and 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 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 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 GLTexCoord1d ( GLdouble s ) [friend]

Replacement of glTexCoord1d.

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 GLTexCoord1i ( GLint s ) [friend]

Replacement of glTexCoord1i.

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 GLTexCoord2d | ( | GLdouble | s,
 |  | GLdouble | t
 | ) | [friend]

Replacement of glTexCoord2d.

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 GLTexCoord2i | ( | GLint | s,
 |  | GLint | t
 | ) | [friend]

Replacement of glTexCoord2i.

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 GLTexCoord3d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r
 | ) | [friend]

Replacement of glTexCoord3d.

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 GLTexCoord3i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r
 | ) | [friend]

Replacement of glTexCoord3i.

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 GLTexCoord4d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r,
 |  | GLdouble | q
 | ) | [friend]

Replacement of glTexCoord4d.

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 GLTexCoord4i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r,
 |  | GLint | q
 | ) | [friend]

Replacement of glTexCoord4i.

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 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 GLTexSubImage1D | ( | GLenum | target,
 |  | GLint | level,
 |  | GLint | xoffset,
 |  | GLsizei | width,
 |  | GLenum | format,
 |  | GLenum | type,
 |  | const GLvoid * | pixels
 | ) | [friend]

Replacement of glTexSubImate1D.

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 glTexSubImate2D.

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 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 GLboolean GLUnmapBuffer ( GLenum target ) [friend]

Replacement of glUnmapBufferARB.

This function hides the extension character of glUnmapBufferARB and 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 GLVertex2f | ( | GLfloat | x,
 |  | GLfloat | y
 | ) | [friend]

Replacement of glVertex2f.

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 GLVertex2s | ( | GLshort | x,
 |  | GLshort | y
 | ) | [friend]

Replacement of glVertex2s.

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 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 GLVertex3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [friend]

Replacement of glVertex3i.

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 GLVertex4d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [friend]

Replacement of glVertex4d.

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 GLVertex4i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [friend]

Replacement of glVertex4i.

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 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 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 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.

The documentation for this class was generated from the following file:
  • GLContext.h
Generated on Fri Aug 4 08:37:19 2006 for NVSGSDK by NVIDIA


Member List

GLContext Member List

This is the complete list of members for GLContext, including all inherited members.
getDisplay() (defined in GLContext) | GLContext | [inline]
GLAccum(GLenum op, GLfloat value) | GLContext | [friend]
GLActiveTexture(GLenum texture) | GLContext | [friend]
GLAlphaFunc(GLenum func, GLclampf ref) | GLContext | [friend]
GLAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) | GLContext | [friend]
GLArrayElement(GLint i) | GLContext | [friend]
GLBegin(GLenum mode) | GLContext | [friend]
GLBeginOcclusionQuery(GLuint id) | GLContext | [friend]
GLBeginQuery(GLenum target, GLuint id) | GLContext | [friend]
GLBindBuffer(GLenum target, GLuint id) | GLContext | [friend]
GLBindProgram(GLenum target, GLuint id) | 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]
GLBlendFunc(GLenum sfactor, GLenum dfactor) | GLContext | [friend]
GLBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) | 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]
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]
GLClearDepth(GLclampd 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]
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]
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]
GLColorMaterial(GLenum face, GLenum mode) | GLContext | [friend]
GLColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | 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]
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]
GLCullFace(GLenum mode) | GLContext | [friend]
GLCullFaceLock (defined in GLContext) | GLContext | [friend]
GLCullFaceUnlock (defined in GLContext) | GLContext | [friend]
GLDeleteBuffers(GLsizei n, const GLuint *buffers) | GLContext | [friend]
GLDeleteLists(GLuint list, GLsizei range) | GLContext | [friend]
GLDeleteOcclusionQueries(GLsizei n, const GLuint *ids) | GLContext | [friend]
GLDeletePrograms(GLsizei n, const GLuint *ids) | GLContext | [friend]
GLDeleteQueries(GLsizei n, const GLuint *ids) | GLContext | [friend]
GLDeleteTextures(GLsizei n, const GLuint *textures) | GLContext | [friend]
GLDepthFunc(GLenum func) | GLContext | [friend]
GLDepthMask(GLboolean flag) | GLContext | [friend]
GLDepthRange(GLclampd znear, GLclampd zfar) | GLContext | [friend]
GLDisable(GLenum cap) | GLContext | [friend]
GLDisableBlend(void) | GLContext | [friend]
GLDisableClientState(GLenum array) | GLContext | [friend]
GLDisableColorArray(void) | GLContext | [friend]
GLDisableColorMaterial(void) | GLContext | [friend]
GLDisableCullFace(void) | GLContext | [friend]
GLDisableCullFaceLock (defined in GLContext) | GLContext | [friend]
GLDisableCullFaceUnlock (defined in GLContext) | GLContext | [friend]
GLDisableDepthTest(void) | GLContext | [friend]
GLDisableFogCoordinateArray(void) | GLContext | [friend]
GLDisableLighting(void) | GLContext | [friend]
GLDisableLightingLock (defined in GLContext) | GLContext | [friend]
GLDisableLightingUnlock (defined in GLContext) | GLContext | [friend]
GLDisableLineSmooth(void) | GLContext | [friend]
GLDisableLineStipple(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]
GLDisablePolygonStipple(void) | GLContext | [friend]
GLDisableSecondaryColorArray(void) | GLContext | [friend]
GLDisableTexture(GLenum target) | GLContext | [friend]
GLDisableTextureCoordArray(void) | GLContext | [friend]
GLDisableTextureGen(GLenum target) | GLContext | [friend]
GLDisableVertexArray(void) | GLContext | [friend]
GLDrawArrays(GLenum mode, GLint first, GLsizei count) | GLContext | [friend]
GLDrawBuffer(GLenum mode) | GLContext | [friend]
GLDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) | 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]
GLEnableBlend(void) | GLContext | [friend]
GLEnableClientState(GLenum array) | GLContext | [friend]
GLEnableColorArray(void) | GLContext | [friend]
GLEnableColorMaterial(void) | GLContext | [friend]
GLEnableCullFace(void) | GLContext | [friend]
GLEnableCullFaceLock (defined in GLContext) | GLContext | [friend]
GLEnableCullFaceUnlock (defined in GLContext) | GLContext | [friend]
GLEnableDepthTest(void) | GLContext | [friend]
GLEnableFogCoordinateArray(void) | GLContext | [friend]
GLEnableLighting(void) | GLContext | [friend]
GLEnableLineSmooth(void) | GLContext | [friend]
GLEnableLineStipple(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]
GLEnablePolygonStipple(void) | GLContext | [friend]
GLEnableSecondaryColorArray(void) | GLContext | [friend]
GLEnableTexture(GLenum target) | GLContext | [friend]
GLEnableTextureCoordArray(void) | GLContext | [friend]
GLEnableTextureGen(GLenum target) | GLContext | [friend]
GLEnableVertexArray(void) | GLContext | [friend]
GLEnd(void) | GLContext | [friend]
GLEndList(void) | GLContext | [friend]
GLEndOcclusionQuery(void) | GLContext | [friend]
GLEndQuery(GLenum target) | 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]
GLFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) | GLContext | [friend]
GLFinish(void) | GLContext | [friend]
GLFlush(void) | GLContext | [friend]
GLFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer) | 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]
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]
GLGenBuffers(GLsizei n, GLuint *buffers) | GLContext | [friend]
GLGenDisplayListCache (defined in GLContext) | GLContext | [friend]
GLGenElementArrayBufferCache (defined in GLContext) | GLContext | [friend]
GLGenLists(GLsizei range) | GLContext | [friend]
GLGenOcclusionQueries(GLsizei n, GLuint *ids) | GLContext | [friend]
GLGenPrograms(GLsizei n, GLuint *ids) | GLContext | [friend]
GLGenQueries(GLsizei n, GLuint *ids) | GLContext | [friend]
GLGenTextureCache (defined in GLContext) | GLContext | [friend]
GLGenTextureCache (defined in GLContext) | GLContext | [friend]
GLGenTextures(GLsizei n, GLuint *textures) | GLContext | [friend]
GLGetBooleanv(GLenum pname, GLboolean *params) | GLContext | [friend]
GLGetClipPlane(GLenum plane, GLdouble *equation) | GLContext | [friend]
GLGetDoublev(GLenum pname, GLdouble *params) | GLContext | [friend]
GLGetFloatv(GLenum pname, GLfloat *params) | 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]
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]
GLGetQueryiv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) | GLContext | [friend]
GLGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) | 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]
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]
GLGetTexParameteriv(GLenum target, GLenum pname, GLint *params) | GLContext | [friend]
GLHint(GLenum target, GLenum mode) | 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]
GLIsBuffer(GLuint name) | GLContext | [friend]
GLIsEnabled(GLenum cap) | GLContext | [friend]
GLIsExtensionAvailable(const std::string &extension) | GLContext | [friend]
GLIsExtensionExported(const std::string &extension) | GLContext | [friend]
GLIsList(GLuint list) | GLContext | [friend]
GLIsOcclusionQuery(GLuint id) | GLContext | [friend]
GLIsProgram(GLuint id) | GLContext | [friend]
GLIsQuery(GLuint id) | GLContext | [friend]
GLIsTexture(GLuint texture) | 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 (defined in GLContext) | GLContext | [friend]
GLLightModelTwoSideUnlock (defined in GLContext) | 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]
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]
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]
GLMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount) | GLContext | [friend]
GLMultiTexCoord2f(GLenum texture, GLfloat tx, GLfloat ty) | 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]
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]
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]
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 (defined in GLContext) | GLContext | [friend]
GLPolygonModeUnlock (defined in GLContext) | 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]
GLPrimitiveRestartIndex(GLuint index) | GLContext | [friend]
GLPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) | GLContext | [friend]
GLProgramNamedParameter4f(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) | 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]
GLRenderMode(GLenum mode) | GLContext | [friend]
GLRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) | 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]
GLSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) | GLContext | [friend]
GLSelectBuffer(GLsizei size, GLuint *buffer) | GLContext | [friend]
GLSetWindowStereoMode(GLboolean displayMode) | GLContext | [friend]
GLShadeModel(GLenum mode) | GLContext | [friend]
GLStencilFunc(GLenum func, GLint ref, GLuint mask) | GLContext | [friend]
GLStencilMask(GLuint mask) | GLContext | [friend]
GLStencilOp(GLenum fail, GLenum zfail, GLenum zpass) | GLContext | [friend]
GLTexCoord1d(GLdouble s) | GLContext | [friend]
GLTexCoord1f(GLfloat s) | GLContext | [friend]
GLTexCoord1i(GLint s) | GLContext | [friend]
GLTexCoord1s(GLshort s) | GLContext | [friend]
GLTexCoord2d(GLdouble s, GLdouble t) | GLContext | [friend]
GLTexCoord2f(GLfloat s, GLfloat t) | GLContext | [friend]
GLTexCoord2fv(const GLfloat *v) | GLContext | [friend]
GLTexCoord2i(GLint s, GLint t) | GLContext | [friend]
GLTexCoord2s(GLshort s, GLshort t) | GLContext | [friend]
GLTexCoord3d(GLdouble s, GLdouble t, GLdouble r) | GLContext | [friend]
GLTexCoord3f(GLfloat s, GLfloat t, GLfloat r) | GLContext | [friend]
GLTexCoord3i(GLint s, GLint t, GLint r) | GLContext | [friend]
GLTexCoord3s(GLshort s, GLshort t, GLshort r) | GLContext | [friend]
GLTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) | GLContext | [friend]
GLTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) | GLContext | [friend]
GLTexCoord4i(GLint s, GLint t, GLint r, GLint q) | GLContext | [friend]
GLTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) | 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]
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]
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]
GLTranslated(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLTranslatef(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLUnmapBuffer(GLenum target) | GLContext | [friend]
GLVertex2d(GLdouble x, GLdouble y) | GLContext | [friend]
GLVertex2f(GLfloat x, GLfloat y) | GLContext | [friend]
GLVertex2i(GLint x, GLint y) | GLContext | [friend]
GLVertex2s(GLshort x, GLshort y) | GLContext | [friend]
GLVertex3d(GLdouble x, GLdouble y, GLdouble z) | GLContext | [friend]
GLVertex3f(GLfloat x, GLfloat y, GLfloat z) | GLContext | [friend]
GLVertex3fv(const GLfloat *v) | GLContext | [friend]
GLVertex3i(GLint x, GLint y, GLint z) | GLContext | [friend]
GLVertex3s(GLshort x, GLshort y, GLshort z) | GLContext | [friend]
GLVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) | GLContext | [friend]
GLVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) | GLContext | [friend]
GLVertex4i(GLint x, GLint y, GLint z, GLint w) | GLContext | [friend]
GLVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) | 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]
GLXAttachContext (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]
GLXMakeCurrent (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]
WGLCreateContext(HDC hdc) | GLContext | [friend]
WGLCreatePbuffer(HDC hdc, int pixelFormat, int width, int height, const int *attribList) | GLContext | [friend]
WGLDeleteContext(HGLRC hglrc) | GLContext | [friend]
WGLDestroyPbuffer(HPBUFFERARB hPbuffer) | GLContext | [friend]
WGLDetachContext (defined in GLContext) | 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 Fri Aug 4 08:37:20 2006 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.

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), wglGetExtensionsStringEXT() (Windows), or glXQueryExtensionsString() (Linux).

Note:
Not all exported extensions might be available.
Returns:
true, if extension is exported, otherwise c\ false
Parameters:
extension extension to test

The documentation for this class was generated from the following file:
  • GLFunctions.h
Generated on Fri Aug 4 08:37:20 2006 for NVSGSDK by NVIDIA


Member List

GLFunctions Member List

This is the complete list of members for GLFunctions, including all inherited members.
GLFunctions(void) | GLFunctions |
isAvailable(const std::string &extension) const | GLFunctions | [inline]
isExported(const std::string &extension) const | GLFunctions | [inline]
~GLFunctions(void) | GLFunctions |
Generated on Fri Aug 4 08:37:20 2006 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

RAMFC_API | GLMFCRAWnd (void)
Default constructor.

virtual RAMFC_API | ~GLMFCRAWnd (void)
Default destructor.

virtual RAMFC_API bool | init (RenderArea *shareArea=NULL)
Create the render area.

RAMFC_API afx_msg BOOL | OnEraseBkgnd (CDC *pDC)
Do nothing in here to avoid flickering.

RAMFC_API afx_msg void | OnPaint (void)
Do nothing other than get the CPaintDC and leave.

virtual RAMFC_API void | setViewportSize (size_t x, size_t y)
Set the size of the window.

virtual RAMFC_API void | destroy ()
Destroy this window.

virtual RAMFC_API void | triggerRedraw ()
Trigger a redraw.

Protected Member Functions

virtual RAMFC_API BOOL | PreCreateWindow (CREATESTRUCT &cs)
Open GL specific base stuff.

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

RAMFC_API GLMFCRAWnd ( void )

Default constructor.

virtual RAMFC_API ~GLMFCRAWnd ( void ) [virtual]

Default destructor.

Member Function Documentation

virtual RAMFC_API bool init ( RenderArea * shareArea = NULL ) [virtual]

Create the render area.

This method creates and initializes the render area.

Returns:
true - everything went fine
Parameters:
shareArea Pointer to a render area with which to share display lists, textures, vertex programs, etc.

Reimplemented from GLWinRenderArea.

RAMFC_API afx_msg BOOL OnEraseBkgnd ( CDC * pDC )

Do nothing in here to avoid flickering.

RAMFC_API afx_msg void OnPaint ( void )

Do nothing other than get the CPaintDC and leave.

virtual RAMFC_API void setViewportSize | ( | size_t | x,
 |  | size_t | y
 | ) | [virtual]

Set the size of the window.

MFC window manager specific wrapper method.

Returns:
true - everything went fine.
Parameters:
x | width in pixels
y | height in pixels

Reimplemented from GLWinRenderArea.

virtual RAMFC_API void destroy ( ) [virtual]

Destroy this window.

MFC window manager specific wrapper method.

Returns:
true - everything went fine.

Reimplemented from GLWinRenderArea.

virtual RAMFC_API void triggerRedraw ( ) [virtual]

Trigger a redraw.

MFC window manager specific wrapper method.

Reimplemented from GLWinRenderArea.

virtual RAMFC_API BOOL PreCreateWindow ( CREATESTRUCT & cs ) [protected, virtual]

Open GL specific base stuff.

The documentation for this class was generated from the following file:
  • GLMFCRAWnd.h
Generated on Fri Aug 4 08:40:07 2006 for NVSGSDK by NVIDIA


Member List

GLMFCRAWnd Member List

This is the complete list of members for GLMFCRAWnd, including all inherited members.
_MULTISAMPLE enum value | RenderArea | [protected]
_STEREO enum value | RenderArea | [protected]
_UNDEFINED enum value | RenderArea | [protected]
attachWindow(HWND hWnd) | GLWinRenderArea | [virtual]
createNewRenderAreaID() | RenderArea | [inline, static]
destroy() | GLMFCRAWnd | [virtual]
determinePixelFormat(void) | GLWinRenderArea | [protected]
disableHWFSAA() | GLWinRenderArea |
enableHWFSAA() | GLWinRenderArea |
getAppTraverser() const | RenderArea | [inline]
getAspectRatio() const | RenderArea | [inline]
getCullTraverser(size_t 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]
GLMFCRAWnd(void) | GLMFCRAWnd |
GLWinRenderArea(void) | GLWinRenderArea |
init(RenderArea *shareArea=NULL) | GLMFCRAWnd | [virtual]
initGL(void) | 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 |
OnEraseBkgnd(CDC *pDC) | GLMFCRAWnd |
OnPaint(void) | GLMFCRAWnd |
pickCameraTargetPoint(int x, int y) | RenderArea |
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(const nvsg::Scene *scene) | RenderArea |
setSceneData(const nvsg::Scene *scene, const nvsg::ViewState *viewState) | RenderArea |
setViewportSize(size_t x, size_t y) | GLMFCRAWnd | [virtual]
setViewState(const nvsg::ViewState *viewState) | RenderArea |
shareLists(GLWinRenderArea *ra) | GLWinRenderArea |
triggerRedraw() | GLMFCRAWnd | [virtual]
wasRenderInterrupted() const | RenderArea | [inline]
~GLMFCRAWnd(void) | GLMFCRAWnd | [virtual]
~GLWinRenderArea(void) | GLWinRenderArea | [virtual]
~RenderArea() | RenderArea | [virtual]
Generated on Fri Aug 4 08:40:07 2006 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.

void | addBuffers (GLsizei n, const GLuint *names)
Add VBO buffers to the set of shareable objects.

void | removeBuffers (GLsizei n, const GLuint *names)
Remove VBO buffers to the set of shareable objects.

void | addLists (GLsizei n, GLuint first)
Add display lists to the set of shareable objects.

void | removeLists (GLsizei n, GLuint first)
Remove display lists from the set of shareable objects.

void | addPrograms (GLsizei n, const GLuint *names)
Add programs to the set of shareable objects.

void | removePrograms (GLsizei n, const GLuint *names)
Remove programs from the set of shareable objects.

void | addTextures (GLsizei n, const GLuint *names)
Add textures to the set of shareable objects.

void | removeTextures (GLsizei n, const GLuint *names)
Remove textures from the set of shareable objects.

void | addOcclusionQueries (GLsizei n, const GLuint *names)
Add occlusion queries to the set of non-shareable objects.

void | removeOcclusionQueries (GLsizei n, const GLuint *names)
Remove occlusion queries from the set of non-shareable objects.

void | addQueries (GLsizei n, const GLuint *names)
Add queries to the set of non-shareable objects.

void | removeQueries (GLsizei n, const GLuint *names)
Remove queries from the set of non-shareable objects.

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.

Member Function Documentation

void addBuffers | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Add VBO buffers to the set of shareable objects.

void removeBuffers | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Remove VBO buffers to the set of shareable objects.

void addLists | ( | GLsizei | n,
 |  | GLuint | first
 | ) | [inline]

Add display lists to the set of shareable objects.

void removeLists | ( | GLsizei | n,
 |  | GLuint | first
 | ) | [inline]

Remove display lists from the set of shareable objects.

void addPrograms | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Add programs to the set of shareable objects.

void removePrograms | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Remove programs from the set of shareable objects.

void addTextures | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Add textures to the set of shareable objects.

void removeTextures | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Remove textures from the set of shareable objects.

void addOcclusionQueries | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Add occlusion queries to the set of non-shareable objects.

void removeOcclusionQueries | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Remove occlusion queries from the set of non-shareable objects.

void addQueries | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Add queries to the set of non-shareable objects.

void removeQueries | ( | GLsizei | n,
 |  | const GLuint * | names
 | ) | [inline]

Remove queries from the set of non-shareable objects.

The documentation for this class was generated from the following file:
  • GLObjects.h
Generated on Fri Aug 4 08:37:20 2006 for NVSGSDK by NVIDIA


Member List

GLObjects Member List

This is the complete list of members for GLObjects, including all inherited members.
addBuffers(GLsizei n, const GLuint *names) | GLObjects | [inline]
addLists(GLsizei n, GLuint first) | GLObjects | [inline]
addOcclusionQueries(GLsizei n, const GLuint *names) | GLObjects | [inline]
addPrograms(GLsizei n, const GLuint *names) | GLObjects | [inline]
addQueries(GLsizei n, const GLuint *names) | GLObjects | [inline]
addTextures(GLsizei n, const GLuint *names) | GLObjects | [inline]
GLObjects() | GLObjects |
removeBuffers(GLsizei n, const GLuint *names) | GLObjects | [inline]
removeLists(GLsizei n, GLuint first) | GLObjects | [inline]
removeOcclusionQueries(GLsizei n, const GLuint *names) | GLObjects | [inline]
removePrograms(GLsizei n, const GLuint *names) | GLObjects | [inline]
removeQueries(GLsizei n, const GLuint *names) | GLObjects | [inline]
removeTextures(GLsizei n, const GLuint *names) | GLObjects | [inline]
~GLObjects() | GLObjects |
Generated on Fri Aug 4 08:37:20 2006 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 on supported jitter techniques.

virtual NVSG_API void | setJitterTechnique (JitterTechnique jt)
Set the jitter technique the render should use.

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 (size_t 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 (size_t 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 (size_t 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.

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 (const nvsg::Scene *pScene)
doApply override to perform a specialized treatment.

virtual NVSG_API void | doRender (const nvsg::Scene *scene)
doRender override to perform GL-rendering

virtual NVSG_API void | handleBitmap (const nvsg::Bitmap *p)
handleBitmap override for specialized handling of Bitmap.

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 | handleMapList (const nvsg::MapList *p)
handleMapList override for specialized handling of MapList.

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 | renderAnimatedQuads (const nvsg::AnimatedQuads *p)
Render an AnimatedQuads out of a render list.

virtual NVSG_API void | renderAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Render an AnimatedTriangles out of a render list.

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 | 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 | 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, size_t 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 | setClipPlane (size_t 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 on supported jitter techniques.

Use this method to test if this special jitter technique is currently available.

Returns:
true - supported, false - not supported
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.
Parameters:
jt Jitter technique.

Reimplemented from RenderTraverser.

virtual NVSG_API void setJitterTechnique ( JitterTechnique jt ) [virtual]

Set the jitter technique the render should use.

Parameters:
jt Jitter technique

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 ( size_t 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 ( size_t 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 ( size_t 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.

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 ( const nvsg::Scene * pScene ) [protected, virtual]

doApply override to perform a specialized treatment.

Reimplemented from RenderTraverser.

virtual NVSG_API void doRender ( const nvsg::Scene * scene ) [protected, virtual]

doRender override to perform GL-rendering

Implements RenderTraverser.

virtual NVSG_API void handleBitmap ( const nvsg::Bitmap * p ) [protected, virtual]

handleBitmap override for specialized handling of Bitmap.

Reimplemented from Traverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

handleLines override for specialized handling of Lines.

Reimplemented from Traverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

handleLineStrips override for specialized handling of LineStrips.

Reimplemented from Traverser.

virtual NVSG_API void handleMapList ( const nvsg::MapList * p ) [protected, virtual]

handleMapList override for specialized handling of MapList.

Reimplemented from Traverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

handlePoints override for specialized handling of Points.

Reimplemented from Traverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

handleQuadMeshes override for specialized handling of QuadMeshes.

Reimplemented from Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

handleQuads override for specialized handling of Quads.

Reimplemented from Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

handleQuadStrips override for specialized handling of QuadStrips.

Reimplemented from Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

handleTriangles override for specialized handling of Triangles.

Reimplemented from Traverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

handleTriFans override for specialized handling of TriFans.

Reimplemented from Traverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

handleTriStrips override for specialized handling of TriStrips.

Reimplemented from Traverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

handleVertexAttributeSet override for specialized handling of VertexAttributeSet.

Reimplemented from Traverser.

virtual NVSG_API void renderAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Render an AnimatedQuads out of a render list.

Draws the current Quads.

Parameters:
p AnimatedQuads to render

Reimplemented from RenderTraverser.

virtual NVSG_API void renderAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Render an AnimatedTriangles out of a render list.

Draws the current Triangles.

Parameters:
p AnimatedTriangles to render

Reimplemented from RenderTraverser.

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 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 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,
 |  | size_t | 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 setClipPlane | ( | size_t | 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 Fri Aug 4 08:39:18 2006 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, HandlerType handler) | Traverser | [inline, protected]
addObjectRenderer(unsigned int objectCode, RendererType renderer) | RenderTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *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]
beginEdit(const T *obj) const | Traverser | [inline, protected]
beginOcclusionCullQuery(unsigned int id) | GLTraverser | [virtual]
clearRenderLists(void) | RenderTraverser | [protected]
createOcclusionCullID(void) | GLTraverser | [virtual]
destroyOcclusionCullID(unsigned int id) | GLTraverser | [virtual]
doApply(const nvsg::Scene *pScene) | GLTraverser | [protected, virtual]
doRender(const nvsg::Scene *scene) | GLTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
endOcclusionCullQuery(unsigned int id) | GLTraverser | [virtual]
GCT_DL enum value | RenderTraverser |
GCT_NONE enum value | RenderTraverser |
GCT_VBO enum value | RenderTraverser |
GeometryCacheTechnique enum name | RenderTraverser |
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]
getMapPosition(size_t &x, size_t &y) | RenderTraverser | [inline, protected]
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]
getProblems() | Traverser |
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]
GLTraverser(void) | GLTraverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | ModelViewTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | GLTraverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | GLTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | GLTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | ModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | RenderTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | RenderTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | GLTraverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | RenderTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | RenderTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | RenderTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [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 *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | RenderTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [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]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | GLTraverser | [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]
isCgFxAware(void) const | RenderTraverser | [inline]
isFaceCullingOverwrite() const | RenderTraverser | [inline]
isFaceModeOverwrite() const | RenderTraverser | [inline]
isFrontFaceCulling() const | RenderTraverser | [inline]
isGeometryCacheTechniqueSupported(GeometryCacheTechnique gct) const | GLTraverser | [virtual]
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]
isTwoSidedLightingOverwrite() const | RenderTraverser | [inline]
isTwoSidedLigthing() const | RenderTraverser | [inline]
JitterTechnique enum name | RenderTraverser |
JT_ACCUM enum value | RenderTraverser |
JT_NONE enum value | RenderTraverser |
JT_PBUFFER enum value | RenderTraverser |
JT_READ_PIXELS enum value | RenderTraverser |
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [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, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OT_PBUFFER enum value | RenderTraverser |
OT_TEXTURE enum value | RenderTraverser |
overlayBegin(void) | GLTraverser | [protected, virtual]
overlayEnd(void) | GLTraverser | [protected, virtual]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | RenderTraverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | RenderTraverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | RenderTraverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | RenderTraverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | RenderTraverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | RenderTraverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | ModelViewTraverser | [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]
renderAnimatedQuads(const nvsg::AnimatedQuads *p) | GLTraverser | [protected, virtual]
renderAnimatedTriangles(const nvsg::AnimatedTriangles *p) | GLTraverser | [protected, virtual]
renderBegin(void) | GLTraverser | [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]
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(const nvsg::Object *object) | RenderTraverser | [inline, protected]
renderObject(const nvsg::Object *object, 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, size_t tu) | GLTraverser | [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]
RT_EFFECTED enum value | RenderTraverser |
RT_SHADED enum value | RenderTraverser |
RT_TEXTURED enum value | RenderTraverser |
RT_UNLIT enum value | RenderTraverser |
setCgFxAwareness(bool aware) | RenderTraverser | [inline, protected]
setClipPlane(size_t index, const nvmath::Plane3f &plane, bool enable) | GLTraverser | [protected, virtual]
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) | GLTraverser | [virtual]
setLineAntiAliasing(bool onOff) | RenderTraverser | [inline]
setLineWidth(float width) | RenderTraverser | [inline]
setLocalViewer(bool onOff) | GLTraverser | [inline]
setOcclusionCulling(bool onOff) | RenderTraverser | [virtual]
setOITMaxPasses(size_t 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 |
setSeparateSpecularColor(bool onOff) | GLTraverser | [inline]
setShadowMapIntensity(float intensity) | RenderTraverser | [inline]
setShadowMapSize(size_t size) | GLTraverser | [virtual]
setShadowTechnique(ShadowTechnique st) | GLTraverser | [virtual]
setSortingPolicy(SortingPolicy sp) | RenderTraverser | [inline]
setTextureSizeLimit(size_t 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(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
ShadowTechnique enum name | RenderTraverser |
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]
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | RenderTraverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | RenderTraverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
TT_BLENDED 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 |
wasTraversalInterrupted() | Traverser | [inline]
~GLTraverser(void) | GLTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~RenderTraverser(void) | RenderTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:18 2006 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 (size_t x, size_t 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.

Protected Member Functions

virtual NVSG_API bool | initGL (void)
Initialize additional OpenGL features.

NVSG_API int | determinePixelFormat (void)
Internal pixel format chooser.

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 | ( | size_t | x,
 |  | size_t | 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

virtual NVSG_API bool initGL ( void ) [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

NVSG_API int determinePixelFormat ( void ) [protected]

Internal pixel format chooser.

Returns:
The pixel format index. A return value larger than 0 is valid. A NULL or negative value indicates a problem. No valid pixel format: 0, no stereo: -1, no FSAA: -2
Remarks:
Determine the OpenGL pixelformat index with respect to the requested features, such as stereo, multisample, etc...
We use the WGL_ARB_pixelformat extension to find the appropriate pixel format. To use this extension we need to create a dummy OpenGL context. We even check this dummy context for stereo (if needed) and hardware acceleration. Missing hardware acceleration is a knock out for the render area. If we can't get a stereo pixel format for the dummy context we report this back to the caller, so init so the caller can restart the pixel format search without a stereo request.
If we can create the dummy context we check for the WGL_ARB_pixelformat extension and try to find a valid pixel format. If WGL_SAMPLE_BUFFERS_ARB (HWFSAA) was requested but not found, we also report this to the caller and the caller can also restart the search without the the HWFSAA request.

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 Fri Aug 4 08:39:56 2006 for NVSGSDK by NVIDIA


Member List

GLWinRenderArea Member List

This is the complete list of members for GLWinRenderArea, including all inherited members.
_MULTISAMPLE enum value | RenderArea | [protected]
_STEREO enum value | RenderArea | [protected]
_UNDEFINED enum value | RenderArea | [protected]
attachWindow(HWND hWnd) | GLWinRenderArea | [virtual]
createNewRenderAreaID() | RenderArea | [inline, static]
destroy(void) | GLWinRenderArea | [virtual]
determinePixelFormat(void) | GLWinRenderArea | [protected]
disableHWFSAA() | GLWinRenderArea |
enableHWFSAA() | GLWinRenderArea |
getAppTraverser() const | RenderArea | [inline]
getAspectRatio() const | RenderArea | [inline]
getCullTraverser(size_t 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(void) | 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 |
pickCameraTargetPoint(int x, int y) | 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(const nvsg::Scene *scene) | RenderArea |
setSceneData(const nvsg::Scene *scene, const nvsg::ViewState *viewState) | RenderArea |
setViewportSize(size_t x, size_t y) | GLWinRenderArea | [virtual]
setViewState(const nvsg::ViewState *viewState) | RenderArea |
shareLists(GLWinRenderArea *ra) | GLWinRenderArea |
triggerRedraw(void) | GLWinRenderArea | [virtual]
wasRenderInterrupted() const | RenderArea | [inline]
~GLWinRenderArea(void) | GLWinRenderArea | [virtual]
~RenderArea() | RenderArea | [virtual]
Generated on Fri Aug 4 08:39:57 2006 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

virtual NVSG_API const Group * | clone () const
Returns a deep-copy of the Group object.

NVSG_API size_t | getNumberOfChildren () const
Returns the number child nodes for this Group.

NVSG_API size_t | addChild (const Node *child, size_t position=0xFFFFFFFF)
Adds a child node.

NVSG_API const Node * | getChild (size_t position) const
Returns the child node at a specified position.

NVSG_API bool | removeChild (const Node *child)
Removes all occurrences of a specified child node from this Group.

NVSG_API void | removeChild (size_t position)
Removes the child node at the specified position.

NVSG_API bool | replaceChild (const Node *newChild, const Node *oldChild)
Replaces all occurrences of a child node.

NVSG_API void | replaceChild (const Node *newChild, size_t position)
Replaces the child node at the specified position.

NVSG_API bool | hasChild (const Node *node) const
Tests whether a specified Node is a child node of this Group.

NVSG_API bool | getChildPositions (const Node *node, std::vector< size_t > &positions) const
Returns all occurring positions of a specified child node.

virtual NVSG_API bool | containsCgFx () const
Tests whether any CgFx attribute is assigned to a geometry underneath this Group.

virtual NVSG_API void | invalidateCgFxContainment ()
Invalidates the CgFx containment cache.

virtual NVSG_API bool | containsLight () const
Returns whether this Group contains any LightSource. Tests whether any LightSource is located underneath this Group.

virtual NVSG_API void | invalidateLightContainment ()
Invalidates the LightSource containment cache.

virtual NVSG_API size_t | getNumberOfFrames () const
Returns the number of animation frames contained.

virtual NVSG_API void | invalidateNumberOfFrames () const
Invalidates the cache for the number of frames contained.

NVSG_API size_t | getNumberOfClipPlanes () const
Get the number of clipping planes in this Group.

NVSG_API size_t | getNumberOfActiveClipPlanes () const
Get the number of active clipping planes in this Group.

NVSG_API bool | isClipPlaneActive (size_t index) const
Ask if the specified clipping plane is active.

NVSG_API const nvmath::Plane3f & | getClipPlane (size_t index) const
Get the specified clipping plane.

NVSG_API void | addClipPlane (const nvmath::Plane3f &plane, bool active=true)
Add a clipping plane to this Group.

NVSG_API void | activateClipPlane (size_t index)
Switch the specified clipping plane to active.

NVSG_API void | deactivateClipPlane (size_t index)
Switch the specified clipping plane to inactive.

NVSG_API void | setClipPlane (size_t index, const nvmath::Plane3f &plane)
Set the plane of the specified clipping plane.

virtual NVSG_API bool | isEquivalent (const Object *object, bool ignoreNames, bool deepCompare) const
Overrides Object::isEquivalent.

NVSG_API Group & | operator= (const Group &rhs)
Assigns new content from another Group object.

Static Public Member Functions

NVSG_API const Group * | create ()
Instantiates a Group object.

NVSG_API const Group * | createFromBase (const Node &rhs)
Instantiates a Group object.

Protected Member Functions

NVSG_API | Group ()
Constructs a Group object.

NVSG_API | Group (const Node &rhs)
Constructs a Group object.

NVSG_API | Group (const Group &rhs)
Constructs a Group object as a copy of another Group object.

virtual NVSG_API | ~Group ()
Destructs a Group object.

virtual NVSG_API void | preRemoveChild (size_t position)
Called from the framework immediately before a child will be removed from the Group.

virtual NVSG_API void | postRemoveChild (size_t position)
Called from the framework immediately after a child has been removed from the Group.

virtual NVSG_API void | preAddChild (size_t position)
Called from the framework immediately before a child will be added to the Group.

virtual NVSG_API void | postAddChild (size_t position)
Called from the framework immediately after a child was added to the Group.

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.

NVSG_API void | invalidateCaches (const Node *child, bool insert)
Invalidates owning caches depending on whether a child node was added or removed.

virtual NVSG_API void | validateIncarnation () const
Validates all incarnations down the hierarchy.

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 ( ) [protected]

Constructs a Group object.

Remarks:
This constructor will be implicitly called through the static member function Group::create.

NVSG_API Group ( const Node & rhs ) [explicit, protected]

Constructs a Group object.

Parameters:
rhs Node object to copy the base class part from.
Remarks:
This constructor will be implicitly called through the static member function Group::createFromBase.

NVSG_API Group ( const Group & rhs ) [protected]

Constructs a Group object as a copy of another Group object.

Parameters:
rhs Group object to serve as source for the newly constructed Group object.
Remarks:
This copy constructor will be implicitly called through the member function Group::clone.

virtual NVSG_API ~Group ( ) [protected, virtual]

Destructs a Group object.

Remarks:
This destructor will be implicitly called if the reference count for a Group object changes from one to zero.

Member Function Documentation

NVSG_API const Group* create ( ) [static]

Instantiates a Group object.

Returns:
The function returns a pointer to the newly created, const Group object.
See also:
NVSG Objects

Reimplemented in Billboard, LOD, Switch, and Transform.

NVSG_API const Group* createFromBase ( const Node & rhs ) [static]

Instantiates a Group object.

Parameters:
rhs Node object to copy the base class part from.
Returns:
The function returns a pointer to the newly created, const Group object.
Remarks:
The function instantiates a Group object and copies the base class part from the Node object passed through rhs.
See also:
NVSG Objects

virtual NVSG_API const Group* clone ( ) const [virtual]

Returns a deep-copy of the Group object.

Returns:
The function returns a pointer to the const Group object that was created as a deep-copy of this Group object.
See also:
NVSG Objects

Implements Node.

Reimplemented in AnimatedTransform, Billboard, LOD, Switch, and Transform.

size_t 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 size_t addChild | ( | const Node * | child,
 |  | size_t | position = 0xFFFFFFFF
 | ) |

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

const Node * getChild ( size_t 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)
 {
     size_t numChilds = group->getNumberOfChildren();
     // iterate through the children and print the name for each in turn
     for ( size_t i=0; i<numChilds; ++i )
     {
         printf("child#%i: %s\n", i, group->getChild(i)->getName().c_str());
     }
 }

NVSG_API bool removeChild ( const Node * 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 ( size_t 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 | ( | const Node * | newChild,
 |  | const Node * | 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 | ( | const Node * | newChild,
 |  | size_t | 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

NVSG_API bool hasChild ( const Node * node ) const

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 | ( | const Node * | node,
 |  | std::vector< size_t > & | 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

virtual NVSG_API bool containsCgFx ( ) const [virtual]

Tests whether any CgFx attribute is assigned to a geometry underneath this Group.

Returns:
The function returns true if at least one CgFx attribute is assigned to a geometry underneath this Group.
Remarks:
The function overrides Node::containsCgFx.

The function tests whether somewhere underneath this Group a CgFx attribute is assigned to a geometry. To determine this, the function needs to iterate through the hierarchy underneath this Group. As this might be an expensive operation, the result of the test will be cached to provide faster access with subsequent queries. If the state of CgFx containment changes somehow, the cache will become invalid, forcing a re-calculation of the result in the very next query.
See also:
Group::invalidateCgFxContainment

Reimplemented from Node.

virtual NVSG_API void invalidateCgFxContainment ( ) [virtual]

Invalidates the CgFx containment cache.

Remarks:
The function overrides Node::invalidateCgFxContainment.

The function invalides this Group's CgFx containment cache and that of the superior hierarchy.
See also:
Group::containsCgFx

Reimplemented from Node.

virtual NVSG_API bool containsLight ( ) const [virtual]

Returns whether this Group contains any LightSource. Tests whether any LightSource is located underneath this Group.

Returns:
The function returns true if at least one LightSource is located underneath this Group. Otherwise, the function returns false.
Remarks:
The function overrides Node::containsLight.

The function tests whether at least one LightSource is located underneath this Group. To determine this, the function needs to iterate through the hierarchy underneath this Group. As this might be an expensive operation, the result of the test will be cached to provide faster access with the next queries. If the state of LightSource containment changes somehow, the cache will become invalid, forcing a re-calculation of the result in the very next query.
See also:
Group::invalidateLightContainment

Reimplemented from Node.

virtual NVSG_API void invalidateLightContainment ( ) [virtual]

Invalidates the LightSource containment cache.

Remarks:
The function overrides Node::invalidateLightContainment.

The function invalides this Group's LightSource containment cache and that of the superior hierarchy.
See also:
Group::containsLight

Reimplemented from Node.

virtual NVSG_API size_t getNumberOfFrames ( ) const [virtual]

Returns the number of animation frames contained.

Returns:
The function returns the actual number of contained animation frames.
Remarks:
The function overrides Node::getNumberOfFrames.

The function iterates the underlying hierarchy for animations to query for the number of frames. As this might be an expensive operation, the result of the test will be cached to provide faster access with the next queries. If the animation state changes underneath this Group, the cache will become invalid, forcing a re-calculation of the result in the very next query.

There currently is a restriction that a Scene must contain animations with exactly the same number of frames.
See also:
Node::getNumberOfFrames, Group::invalidateNumberOfFrames

Reimplemented from Node.

Reimplemented in AnimatedTransform.

virtual NVSG_API void invalidateNumberOfFrames ( ) const [virtual]

Invalidates the cache for the number of frames contained.

Remarks:
The function overrides Node::invalidateNumberOfFrames.

The function invalides this Group's cache for the number of frames contained and that of the superior hierarchy.
See also:
Group::getNumberOfFrames

Reimplemented from Node.

size_t 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 size_t 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 ( size_t 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 ( size_t index ) const [inline]

Get the specified clipping plane.

Parameters:
index The index in the array of clipping planes.
Returns:
A reference to the constant cliping plane.
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]

Add a clipping plane to this Group.

Parameters:
plane | A reference to the constant clipping plane to add.
active | Optional parameter to add the clipping plane as active (true) or inactive (false); default is active.
See also:
getNumberOfClipPlanes, isClipPlaneActive, getClipPlane

void activateClipPlane ( size_t index ) [inline]

Switch the specified clipping plane to active.

Parameters:
index The index in the array of clipping planes.
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, deactivateClipPlane

void deactivateClipPlane ( size_t index ) [inline]

Switch the specified clipping plane to inactive.

Parameters:
index The index in the array of clipping planes.
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, activateClipPlane

void setClipPlane | ( | size_t | index,
 |  | const nvmath::Plane3f & | plane
 | ) | [inline]

Set the plane of the specified clipping plane.

Parameters:
index | The index in the array of clipping planes.
plane | A reference to the constant plane to use as the clipping plane.
Note:
The behavior is undefined if index is larger than or equal to the number of clipping planes in this Group.
See also:
getNumberOfClipPlanes, activateClipPlane, deactivateClipPlane

virtual NVSG_API bool isEquivalent | ( | const Object * | object,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Overrides Object::isEquivalent.

Parameters:
object | 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, 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 void preRemoveChild ( size_t 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 ( size_t 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 ( size_t 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 ( size_t 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::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 containsHints is called while the hint containment flags mark that information as invalid.
See also:
containsHints, invalidateHintsContainment

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.

NVSG_API void invalidateCaches | ( | const Node * | 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

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 Object.

Reimplemented in AnimatedTransform.

The documentation for this class was generated from the following file:
  • Group.h
Generated on Fri Aug 4 08:37:53 2006 for NVSGSDK by NVIDIA


Member List

Group Member List

This is the complete list of members for Group, including all inherited members.
activateClipPlane(size_t index) | Group | [inline]
addChild(const Node *child, size_t position=0xFFFFFFFF) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | Group | [protected, virtual]
clone() const | Group | [virtual]
containsCgFx() const | Group | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Group | [virtual]
containsTransparentGeometry() const | Node |
create() | Group | [static]
createFromBase(const Node &rhs) | Group | [static]
deactivateClipPlane(size_t index) | Group | [inline]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getChild(size_t position) const | Group | [inline]
getChildPositions(const Node *node, std::vector< size_t > &positions) const | Group |
getClipPlane(size_t index) const | Group | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfFrames() const | Group | [virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
Group() | Group | [protected]
Group(const Node &rhs) | Group | [explicit, protected]
Group(const Group &rhs) | Group | [protected]
hasChild(const Node *node) const | Group |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const Node *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Group | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Group | [virtual]
invalidateNumberOfFrames() const | Group | [virtual]
invalidateTransparencyContainment() | Node |
isClipPlaneActive(size_t index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames, bool deepCompare) const | Group | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Group &rhs) | Group |
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
postAddChild(size_t position) | Group | [protected, virtual]
postRemoveChild(size_t position) | Group | [protected, virtual]
preAddChild(size_t position) | Group | [protected, virtual]
preRemoveChild(size_t position) | Group | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeChild(const Node *child) | Group |
removeChild(size_t position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceChild(const Node *newChild, const Node *oldChild) | Group |
replaceChild(const Node *newChild, size_t position) | Group |
setAnnotation(const std::string &anno) | Node |
setClipPlane(size_t index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Group | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Group() | Group | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:53 2006 for NVSGSDK by NVIDIA


GroupEliminateTraverser Class Reference

Traverser that eliminates unneccessary Groups. More...

#include <GroupEliminateTraverser.h>

Inheritance diagram for GroupEliminateTraverser:

[legend]
Collaboration diagram for GroupEliminateTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | GroupEliminateTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~GroupEliminateTraverser (void)
Protected destructor to prevent instantiation of a GroupEliminateTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
If the root node is a Group with a single child, it is removed.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
If the AnimatedTransform holds other Groups without lights, they are replaced by their children.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
If the Billboard holds Groups without lights, they are replaced by their children.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
If the Group holds other Groups without lights, they are replaced by their children.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
If the LOD holds Groups with one child (no light!), they are replaced by their respective child.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
If the Switch holds Groups with one child (no light!), they are replaced by their respective child.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
If the Transform holds Groups without lights, they are replaced by their children.

Detailed Description

Traverser that eliminates unneccessary Groups.

A Group is unneccessary if one of the following holds:

  • It is beneath a Group or a Transform and holds no lights
  • It is beneath a LOD or a Switch or is the root node of the tree, and holds exactly one child. Then the Group can simply be replaced by it child/children.

Constructor & Destructor Documentation

NVSG_API GroupEliminateTraverser ( void )

Constructor.

virtual NVSG_API ~GroupEliminateTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a GroupEliminateTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * scene ) [protected, virtual]

If the root node is a Group with a single child, it is removed.

Parameters:
scene Scene to traverse and handle

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

If the AnimatedTransform holds other Groups without lights, they are replaced by their children.

An AnimatedTransform is handled as a Transform.

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

If the Billboard holds Groups without lights, they are replaced by their children.

Parameters:
p Points to the currently visited Billboard object.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

If the Group holds other Groups without lights, they are replaced by their children.

Parameters:
p Points to the currently visited Group object.

Reimplemented from Traverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

If the LOD holds Groups with one child (no light!), they are replaced by their respective child.

Parameters:
p Points to the currently visited LOD object.

Reimplemented from Traverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

If the Switch holds Groups with one child (no light!), they are replaced by their respective child.

Parameters:
p Points to the currently visited Switch object.

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

If the Transform holds Groups without lights, they are replaced by their children.

Parameters:
p Points to the currently visited Transform object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • GroupEliminateTraverser.h
Generated on Fri Aug 4 08:39:20 2006 for NVSGSDK by NVIDIA


Member List

GroupEliminateTraverser Member List

This is the complete list of members for GroupEliminateTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | GroupEliminateTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
GroupEliminateTraverser(void) | GroupEliminateTraverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | GroupEliminateTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | GroupEliminateTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | GroupEliminateTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | GroupEliminateTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | GroupEliminateTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | GroupEliminateTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~GroupEliminateTraverser(void) | GroupEliminateTraverser | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:20 2006 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

virtual NVSG_API const HighlightBox * | clone () const
Create a new HighlightBox by copying from this.

virtual NVSG_API void | validate (const Drawable *drawable)
Validate the highlight geometry.

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.

Static Public Member Functions

NVSG_API const HighlightBox * | create ()
Create a HighlightBox.

NVSG_API const HighlightBox * | createFromBase (const HighlightObject &rhs)
Create a HighlightBox by copying from a HighlightObject.

Protected Member Functions

NVSG_API | HighlightBox ()
Protected constructor to prevent explicit creation.

NVSG_API | HighlightBox (const HighlightObject &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | HighlightBox (const HighlightBox &rhs)
Protected copy constructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside HighlightBox::create.

NVSG_API HighlightBox ( const HighlightObject & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant HighlightObject to use as a base of the new HighlightBox.
Remarks:
This constructor is never used explicitly, but only inside HighlightBox::createFromBase.
See also:
HighlightObject

NVSG_API HighlightBox ( const HighlightBox & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant HighlightBox to copy from.
Remarks:
This constructor is never used explicitly, but only inside HighlightBox::create.

Member Function Documentation

NVSG_API const HighlightBox* create ( ) [static]

Create a HighlightBox.

Returns:
A pointer to a constant 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 const HighlightBox* createFromBase ( const HighlightObject & rhs ) [static]

Create a HighlightBox by copying from a HighlightObject.

Parameters:
rhs A reference to the constant HighlightObject to copy from
Returns:
A pointer to a constant HighlightBox
Remarks:
All the data from the HighlightObect rhs is used as the base information for the newly created HighlightBox. Data specific to a HighlightBox is initialized as if HighlightBox::create was called.
See also:
HighlightObject

virtual NVSG_API const HighlightBox* clone ( ) const [virtual]

Create a new HighlightBox by copying from this.

Returns:
A pointer to a constant HighlightBox.
Remarks:
The newly created HighlightBox is an exact copy of this.

virtual NVSG_API void validate ( const Drawable * drawable ) [virtual]

Validate the highlight geometry.

Parameters:
drawable A pointer to the constant Drawable to highlight.
Remarks:
Calculates the bounding box of drawable to use as the highlight geometry.
See also:
Drawable, HighlightObject

Reimplemented from HighlightObject.

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.

nvmath::Sphere3f calculateBoundingSphere ( ) const [inline, 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 Fri Aug 4 08:37:54 2006 for NVSGSDK by NVIDIA


Member List

HighlightBox Member List

This is the complete list of members for HighlightBox, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
calculateBoundingSphere() const | HighlightBox | [inline, protected, virtual]
clone() const | HighlightBox | [virtual]
create() | HighlightBox | [static]
createFromBase(const HighlightObject &rhs) | HighlightBox | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getBoundingSphere() const | HighlightObject |
getColor() const | HighlightBox | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getLineWidth() const | HighlightBox | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getVertices() const | HighlightBox | [inline]
HighlightBox() | HighlightBox | [protected]
HighlightBox(const HighlightObject &rhs) | HighlightBox | [explicit, protected]
HighlightBox(const HighlightBox &rhs) | HighlightBox | [protected]
HighlightObject() | HighlightObject | [protected]
HighlightObject(const HighlightObject &rhs) | HighlightObject | [protected]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidate() | HighlightObject | [inline]
invalidateBoundingSphere() | HighlightObject |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isValid() const | HighlightObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const HighlightBox &rhs) | HighlightBox |
nvsg::HighlightObject::operator=(const HighlightObject &rhs) | HighlightObject | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setColor(const nvmath::Vec3f &color) | HighlightBox | [inline]
setLineWidth(float width) | HighlightBox | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validate(const Drawable *drawable) | HighlightBox | [virtual]
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~HighlightObject() | HighlightObject | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:54 2006 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

virtual NVSG_API const HighlightEdges * | clone () const
Create a new HighlightEdges by copying from this.

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 const PrimitiveSet * | getPrimitiveSet () const
Get the PrimitiveSet.

NVSG_API HighlightEdges & | operator= (const HighlightEdges &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const HighlightEdges * | create (const PrimitiveSet *p)
Create a HighlightEdges.

NVSG_API const HighlightEdges * | createFromBase (const HighlightObject &rhs, const PrimitiveSet *p)
Create a HighlightEdges by copying from a HighlightObject.

Protected Member Functions

NVSG_API | HighlightEdges (const PrimitiveSet *p)
Protected constructor to prevent explicit creation.

NVSG_API | HighlightEdges (const HighlightObject &rhs, const PrimitiveSet *p)
Protected constructor to prevent explicit creation.

NVSG_API | HighlightEdges (const HighlightEdges &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~HighlightEdges ()
Protected destructor to prevent explicit creation.

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 ( const PrimitiveSet * p ) [protected]

Protected constructor to prevent explicit creation.

Parameters:
p A pointer to the constant PrimitiveSet to highlight.
Remarks:
This constructor is never used explicitly, but only inside HighlightEdges::create.
See also:
PrimitiveSet

NVSG_API HighlightEdges | ( | const HighlightObject & | rhs,
 |  | const PrimitiveSet * | p
 | ) | [protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs | A reference to the constant HighlightObject to use as a base of the new HighlightEdges.
p | A pointer to the constant PrimitiveSet to highlight.
Remarks:
This constructor is never used explicitly, but only inside HighlightEdges::createFromBase.
See also:
HighlightObject, PrimitiveSet

NVSG_API HighlightEdges ( const HighlightEdges & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant HighlightEdges to copy from.
Remarks:
This constructor is never used explicitly, but only inside HighlightEdges::create.

virtual NVSG_API ~HighlightEdges ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the HighlightEdges is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const HighlightEdges* create ( const PrimitiveSet * p ) [static]

Create a HighlightEdges.

Parameters:
p A pointer to the constant PrimitiveSet that is to be highlighted
Returns:
A pointer to a constant HighlightEdges
Remarks:
The HighlightEdges has a default line width of 2.0 and a default line color of red (1.0,0.0,0.0). It holds the vertex informations of p.

NVSG_API const HighlightEdges* createFromBase | ( | const HighlightObject & | rhs,
 |  | const PrimitiveSet * | p
 | ) | [static]

Create a HighlightEdges by copying from a HighlightObject.

Parameters:
rhs | A reference to the constant HighlightObject to copy from
p | A pointer to the constant PrimitiveSet that is to be highlighted
Returns:
A pointer to a constant HighlightEdges
Remarks:
All the data from the HighlightObect rhs is used as the base information for the newly created HighlightEdges. Data specific to a HighlightEdges is initialized as if HighlightEdges::create was called.
See also:
HighlightObject

virtual NVSG_API const HighlightEdges* clone ( ) const [virtual]

Create a new HighlightEdges by copying from this.

Returns:
A pointer to a constant HighlightEdges.
Remarks:
The newly created HighlightEdges is an exact copy of this.

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.

const PrimitiveSet * getPrimitiveSet ( ) const [inline]

Get the PrimitiveSet.

Returns:
A pointer to the constant PrimitiveSet.
Remarks:
A HighlightEdges holds a PrimitiveSet with vertices only. This can be used for drawing the HighlightEdges.
See also:
PrimitiveSet

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.

nvmath::Sphere3f calculateBoundingSphere ( ) const [inline, 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 Fri Aug 4 08:37:56 2006 for NVSGSDK by NVIDIA


Member List

HighlightEdges Member List

This is the complete list of members for HighlightEdges, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
calculateBoundingSphere() const | HighlightEdges | [inline, protected, virtual]
clone() const | HighlightEdges | [virtual]
create(const PrimitiveSet *p) | HighlightEdges | [static]
createFromBase(const HighlightObject &rhs, const PrimitiveSet *p) | HighlightEdges | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getBoundingSphere() const | HighlightObject |
getColor() const | HighlightEdges | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getLineWidth() const | HighlightEdges | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getPrimitiveSet() const | HighlightEdges | [inline]
HighlightEdges(const PrimitiveSet *p) | HighlightEdges | [protected]
HighlightEdges(const HighlightObject &rhs, const PrimitiveSet *p) | HighlightEdges | [protected]
HighlightEdges(const HighlightEdges &rhs) | HighlightEdges | [protected]
HighlightObject() | HighlightObject | [protected]
HighlightObject(const HighlightObject &rhs) | HighlightObject | [protected]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidate() | HighlightObject | [inline]
invalidateBoundingSphere() | HighlightObject |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isValid() const | HighlightObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const HighlightEdges &rhs) | HighlightEdges |
nvsg::HighlightObject::operator=(const HighlightObject &rhs) | HighlightObject | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setColor(const nvmath::Vec3f &color) | HighlightEdges | [inline]
setLineWidth(float width) | HighlightEdges | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validate(const Drawable *drawable) | HighlightObject | [virtual]
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~HighlightEdges() | HighlightEdges | [protected, virtual]
~HighlightObject() | HighlightObject | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:56 2006 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

NVSG_API const nvmath::Sphere3f & | getBoundingSphere () const
Get the bounding sphere of this .

NVSG_API void | invalidateBoundingSphere ()
Invalidate the bounding sphere of this HighlightObject.

NVSG_API void | invalidate ()
Invalidate the HighlightObject.

NVSG_API bool | isValid () const
Query, if the HighlightObject is valid.

virtual NVSG_API void | validate (const Drawable *drawable)
Validate the 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 | ~HighlightObject ()
Protected destructor to prevent explicit creation.

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

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.

virtual NVSG_API ~HighlightObject ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the HighlightObject is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

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, invalidateBoundingSphere

NVSG_API void invalidateBoundingSphere ( )

Invalidate the bounding sphere of this HighlightObject.

Remarks:
If the bounding sphere currently is marked as valid, it is marked as invalid.
See also:
calculateBoundingSphere, getBoundingSphere

void invalidate ( ) [inline]

Invalidate the HighlightObject.

Remarks:
When the HighlightObject is marked as invalid, it needs recalculation.
See also:
isValid, validate

bool isValid ( ) const [inline]

Query, if the HighlightObject is valid.

Returns:
true, if the HighlightObject is valid, otherwise false.
Remarks:
When the HighlightObject is marked as invalid, it needs recalculation. This is the case before the first rendering, and every time the associated geometry is changed.
See also:
invalidate, validate

virtual NVSG_API void validate ( const Drawable * drawable ) [virtual]

Validate the HighlightObject.

Parameters:
drawable A pointer to the constant Drawable to use for validation.
Remarks:
The base implementation just marks this HighlightObject to be valid.
See also:
invalidate, isValid

Reimplemented in HighlightBox.

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 Fri Aug 4 08:37:56 2006 for NVSGSDK by NVIDIA


Member List

HighlightObject Member List

This is the complete list of members for HighlightObject, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
calculateBoundingSphere() const=0 | HighlightObject | [protected, pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getBoundingSphere() const | HighlightObject |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
HighlightObject() | HighlightObject | [protected]
HighlightObject(const HighlightObject &rhs) | HighlightObject | [protected]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidate() | HighlightObject | [inline]
invalidateBoundingSphere() | HighlightObject |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isValid() const | HighlightObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const HighlightObject &rhs) | HighlightObject | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validate(const Drawable *drawable) | HighlightObject | [virtual]
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~HighlightObject() | HighlightObject | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:56 2006 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, 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,
 |  | 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 Fri Aug 4 08:40:09 2006 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, void *p) | IAllocator | [inline]
theAllocator typedef | IAllocator |
~IAllocator() | IAllocator | [inline, virtual]
Generated on Fri Aug 4 08:40:09 2006 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

size_t | 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

size_t identityCount

The number of identity Transforms.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:05 2006 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 Fri Aug 4 08:39:05 2006 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 | doApply (const nvsg::Scene *scene)
If the root node is an identity Transform, it is replaced by a Group.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
Replace any identity Transform of it's children to a Group.

virtual NVSG_API void | handleTransform (const 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 doApply ( const nvsg::Scene * scene ) [protected, virtual]

If the root node is an identity Transform, it is replaced by a Group.

Parameters:
scene scene that holds tree to be optimized

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Parameters:
p points to the currently visited Billboard object.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Parameters:
p points to the currently visited Group

Reimplemented from Traverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Parameters:
p points to the currently visited LOD

Reimplemented from Traverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Parameters:
p points to the currently visited Switch

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Replace any identity Transform of it's children to a Group.

Parameters:
p points to the currently visited Transform object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • IdentityToGroupTraverser.h
Generated on Fri Aug 4 08:39:21 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | IdentityToGroupTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | IdentityToGroupTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | IdentityToGroupTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | IdentityToGroupTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | IdentityToGroupTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | IdentityToGroupTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | IdentityToGroupTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
IdentityToGroupTraverser(void) | IdentityToGroupTraverser |
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~IdentityToGroupTraverser(void) | IdentityToGroupTraverser | [protected, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:21 2006 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.

const nvsg::TextureImage * | load (const std::string &filename)
Realization of the pure virtual interface function to load a Texture.

Protected Member Functions

virtual | ~ILTexLoader ()
Protected virtual destructor.

Static Protected Attributes

ILTexLoader * | m_instance
size_t | m_refCount

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.

const nvsg::TextureImage* load ( const std::string & filename ) [virtual]

Realization of the pure virtual interface function to load a Texture.

Loads a texture file given by filename.

Returns:
A pointer to the loaded Texture if successful, a null pointer otherwise.
Parameters:
filename texture file to load

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 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

The documentation for this class was generated from the following file:
  • ILTexLoader.h
Generated on Fri Aug 4 08:36:31 2006 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]
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) | ILTexLoader | [virtual]
m_instance (defined in ILTexLoader) | ILTexLoader | [protected, static]
m_refCount (defined in ILTexLoader) | ILTexLoader | [protected, static]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
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 Fri Aug 4 08:36:31 2006 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 Fri Aug 4 08:40:09 2006 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 Fri Aug 4 08:40:09 2006 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 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 size_t | 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, size_t numIndices)
Set the indices of this IndependentPrimitiveSet.

NVSG_API void | setIndices (size_t pos, const unsigned int *indices, size_t 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.

virtual NVSG_API const IndependentPrimitiveSet * | clone () const=0
Interface for creating a new IndependentPrimitiveSet by copying from this.

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 | ~IndependentPrimitiveSet ()
Protected destructor to prevent explicit creation.

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

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.

virtual NVSG_API ~IndependentPrimitiveSet ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the IndependentPrimitiveSet is decremented to zero.
See also:
addRef, removeRef

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

size_t 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,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const unsigned int * | indices,
 |  | size_t | 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 AnimatedQuads, AnimatedTriangles, and SkinnedTriangles.

virtual NVSG_API const IndependentPrimitiveSet* clone ( ) const [pure virtual]

Interface for creating a new IndependentPrimitiveSet by copying from this.

Returns:
A pointer to a constant IndependentPrimitiveSet.
Remarks:
The newly created IndependentPrimitiveSet is an exact copy of this.

Implements PrimitiveSet.

Implemented in AnimatedQuads, AnimatedTriangles, Lines, Points, Quads, SkinnedTriangles, and Triangles.

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.

Reimplemented from PrimitiveSet.

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 Fri Aug 4 08:37:58 2006 for NVSGSDK by NVIDIA


Member List

IndependentPrimitiveSet Member List

This is the complete list of members for IndependentPrimitiveSet, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
clone() const=0 | IndependentPrimitiveSet | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:58 2006 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 Fri Aug 4 08:36:31 2006 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 Fri Aug 4 08:36:31 2006 for NVSGSDK by NVIDIA


TemplateInterpolatedAnimation class Reference

InterpolatedAnimation Class Template Reference

Abstract base class for an interpolated Animation of type T. More...

#include <InterpolatedAnimation.h>

Inheritance diagram for InterpolatedAnimation:

[legend]
Collaboration diagram for InterpolatedAnimation:

[legend]
List of all members.

Public Member Functions

virtual size_t | getNumberOfFrames (void) const
Get the number of animation frames.

size_t | getNumberOfKeys (void) const
Get the number of keys in this InterpolatedAnimation.

void | setNumberOfKeys (size_t count)
Set the number of keys in this InterpolatedAnimation.

void | setKeyFrame (size_t key, unsigned int frame, const T &value)
Set the frame for a key.

unsigned int | getFrame (size_t key) const
Get the frame index corresponding to the key key.

const T & | getValue (size_t key) const
Get the value of type T corresponding to the key key.

virtual bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another InterpolatedAnimation of type T.

Protected Member Functions

InterpolatedAnimation (void)
Protected constructor to prevent explicit creation.

InterpolatedAnimation (const InterpolatedAnimation &rhs)
Protected copy constructor to prevent explicit creation.

virtual | ~InterpolatedAnimation (void)
Protected destructor to prevent explicit creation.

unsigned int | getCurrentFrame (void) const
Get the current frame index.

const T & | getCurrentValue (void) const
Get the current value of type T.

size_t | getKey (unsigned int frame) const
Get the key above or equal to frame frame.

void | setCurrent (size_t key) const
Set the frame and value of key index key as current.

void | setCurrent (unsigned int frame, const T &value) const
Set frame and value as the current.

InterpolatedAnimation< T > & | operator= (const InterpolatedAnimation< T > &rhs)
Protected assignment operator.

Detailed Description

template<typename T>
class nvsg::InterpolatedAnimation< T >

Abstract base class for an interpolated Animation of type T.

Namespace: nvsg
Remarks:
An InterpolatedAnimation 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 succesive 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

InterpolatedAnimation ( 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 InterpolatedAnimation is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.

InterpolatedAnimation ( const InterpolatedAnimation< 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 InterpolatedAnimation is an abstract class, its constructor is never used explicitly, but in the constructor of derived classes.

~InterpolatedAnimation ( void ) [inline, protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the InterpolatedAnimation is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

size_t getNumberOfFrames ( void ) const [inline, virtual]

Get the number of animation frames.

Returns:
The number of frames in this InterpolatedAnimation
Remarks:
The number of frames is the frame of the last key, plus one
See also:
getNumberOfKeys

Implements Animation.

size_t getNumberOfKeys ( void ) const [inline]

Get the number of keys in this InterpolatedAnimation.

Returns:
The number of keys
Remarks:
For each key, there is the frame of this key, and the value of type T that is to be interpolated between the frames of succesive keys.
See also:
getNumberOfFrames, setNumberOfKeys, setKeyFrame

void setNumberOfKeys ( size_t count ) [inline]

Set the number of keys in this InterpolatedAnimation.

Parameters:
count The number of keys
Remarks:
Resizes the arrays of frames and values. On growing these arrays, the new elements are not initialized.
See also:
getNumberOfKeys, setKeyFrame

void setKeyFrame | ( | size_t | key,
 |  | unsigned int | frame,
 |  | const T & | value
 | ) | [inline]

Set the frame for a key.

Parameters:
key | The index of the key to set
frame | The index of the frame corresponding to key
value | The value of type T of the frame corresponding to key
Note:
The behavior is undefined if key is greater than or equal to the number of keys.
See also:
getNumberOfKeys, setNumberOfKeys

unsigned int getFrame ( size_t key ) const [inline]

Get the frame index corresponding to the key key.

Parameters:
key The key index from which to get the corresponding frame
Returns:
The frame 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, getValue

const T & getValue ( size_t 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:
getFrame, getNumberOfKeys

bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [inline, virtual]

Test for equivalence with another InterpolatedAnimation of type T.

Parameters:
p | A reference to the constant InterpolatedAnimation 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 InterpolatedAnimation p of type T is equivalent to this, otherwise false.
Remarks:
Two InterpolatedAnimation 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 InterpolatedAnimation of type T nor derived from one.
See also:
Animation

Reimplemented from Object.

unsigned int getCurrentFrame ( void ) const [inline, protected]

Get the current frame index.

Returns:
The current frame index.
Remarks:
The current frame index is the index of the frame that was most recently requested.
See also:
getCurrentValue, setCurrent

const T & getCurrentValue ( void ) const [inline, protected]

Get the current value of type T.

Returns:
The current value of type T.
Remarks:
The current value is the value of the frame that was most recently requested.
See also:
getCurrentFrame, setCurrent

size_t 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:
getNumberOfFrames

void setCurrent ( size_t key ) const [inline, protected]

Set the frame and value of key index key as current.

Parameters:
key The key index to set its frame index and value as current.
Remarks:
The frame and value corresponding to the key index key are set as current.
Note:
The behavior is undefined if key is greater than or equal to the number of keys.
See also:
getCurrentFrame, getCurrentValue

void setCurrent | ( | unsigned int | frame,
 |  | const T & | value
 | ) | const [inline, protected]

Set frame and value as the current.

Parameters:
frame | The frame index to use as the current.
value | The value to use as the current.
See also:
getCurrentFrame, getCurrentValue, setCurrent

InterpolatedAnimation< T > & operator= ( const InterpolatedAnimation< T > & rhs ) [protected]

Protected assignment operator.

Parameters:
rhs Reference of the constant InterpolatedAnimation of type T to copy from
Returns:
A reference to the assigned InterpolatedAnimation 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:
  • InterpolatedAnimation.h
Generated on Fri Aug 4 08:37:59 2006 for NVSGSDK by NVIDIA


Member List

InterpolatedAnimation Member List

This is the complete list of members for InterpolatedAnimation, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
Animation(void) | Animation | [protected]
clone(void) const=0 | Animation | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getCurrentFrame(void) const | InterpolatedAnimation | [inline, protected]
getCurrentValue(void) const | InterpolatedAnimation | [inline, protected]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFrame(size_t key) const | InterpolatedAnimation | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getKey(unsigned int frame) const | InterpolatedAnimation | [inline, protected]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | InterpolatedAnimation | [inline, virtual]
getNumberOfKeys(void) const | InterpolatedAnimation | [inline]
getObjectCode() const | Object | [inline]
getValue(size_t key) const | InterpolatedAnimation | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
InterpolatedAnimation(void) | InterpolatedAnimation | [inline, protected]
InterpolatedAnimation(const InterpolatedAnimation &rhs) | InterpolatedAnimation | [inline, protected]
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | InterpolatedAnimation | [inline, virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const InterpolatedAnimation< T > &rhs) | InterpolatedAnimation | [protected]
nvsg::Animation::operator=(const Animation< T > &rhs) | Animation | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
operator[](size_t i) const=0 | Animation | [pure virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setCurrent(size_t key) const | InterpolatedAnimation | [inline, protected]
setCurrent(unsigned int frame, const T &value) const | InterpolatedAnimation | [inline, protected]
setKeyFrame(size_t key, unsigned int frame, const T &value) | InterpolatedAnimation | [inline]
setName(const std::string &name) | Object |
setNumberOfKeys(size_t count) | InterpolatedAnimation | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Animation(void) | Animation | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~InterpolatedAnimation(void) | InterpolatedAnimation | [inline, protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:37:59 2006 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

NVSG_API | Intersection (const nvsg::Path *pPath, const nvsg::Drawable *pDrawable, const nvmath::Vec3f &isp, float dist, size_t primitiveIndex, const std::vector< unsigned int > &vertexIndices)
Contructor.

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 const nvsg::Drawable * | 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 size_t | 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

Intersection (void)
Default constructor.

NVSG_API void | clone (const Intersection &rhs)
Clone the whole object.

Protected Attributes

const nvsg::Drawable * | 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.

size_t | 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 | ( | const nvsg::Path * | pPath,
 |  | const nvsg::Drawable * | pDrawable,
 |  | const nvmath::Vec3f & | isp,
 |  | float | dist,
 |  | size_t | primitiveIndex,
 |  | const std::vector< unsigned int > & | vertexIndices
 | ) | [inline]

Contructor.

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.

Intersection ( void ) [inline, protected]

Default constructor.

The user has to use the other constructors!

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.

const nvsg::Drawable * 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.

size_t 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

const nvsg::Drawable* 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.

size_t 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 Fri Aug 4 08:39:31 2006 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(const nvsg::Path *pPath, const nvsg::Drawable *pDrawable, const nvmath::Vec3f &isp, float dist, size_t primitiveIndex, const std::vector< unsigned int > &vertexIndices) | Intersection | [inline]
Intersection(const Intersection &rhs) | Intersection | [inline]
Intersection(void) | Intersection | [inline, protected]
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 Fri Aug 4 08:39:31 2006 for NVSGSDK by NVIDIA


ISWMRSync Class Reference

Single write, multiple read synchronization interface. More...

#include <SWMRSync.h>

Inheritance diagram for ISWMRSync:

[legend]
List of all members.

Public Member Functions

NVSG_API bool | waitToWrite () const
Waits until getting exclusive access to the sync object.

NVSG_API void | doneWriting () const
Releases exclusive access to the sync object.

NVSG_API bool | waitToRead () const
Waits until getting shared access to the sync object.

NVSG_API void | doneReading () const
Releases shared access to the sync object.

Protected Member Functions

ISWMRSync (const ISWMRSync &)
ISWMRSync & | operator= (const ISWMRSync &)

Detailed Description

Single write, multiple read synchronization interface.

Member Function Documentation

bool waitToWrite ( ) const [inline]

Waits until getting exclusive access to the sync object.

Returns:
true after getting exclusive access to the sync object.

void doneWriting ( ) const [inline]

Releases exclusive access to the sync object.

bool waitToRead ( ) const [inline]

Waits until getting shared access to the sync object.

Returns:
true after getting shared access to the sync object.

void doneReading ( ) const [inline]

Releases shared access to the sync object.

The documentation for this class was generated from the following file:
  • SWMRSync.h
Generated on Fri Aug 4 08:40:20 2006 for NVSGSDK by NVIDIA


Member List

ISWMRSync Member List

This is the complete list of members for ISWMRSync, including all inherited members.
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
Generated on Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:39:57 2006 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 Fri Aug 4 08:39:57 2006 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 Fri Aug 4 08:36:31 2006 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 Fri Aug 4 08:36:31 2006 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 Fri Aug 4 08:38:54 2006 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, 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 Fri Aug 4 08:38:54 2006 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

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 | isShadowCasting () const
Query if this LightSource casts shadows.

NVSG_API void | setShadowCasting (bool cast)
Set the shadow casting state of this LightSource.

NVSG_API const Animation<
nvmath::Trafo > * 		getAnimation () const
Get the Animation of this LightSource.

NVSG_API void | setAnimation (const Animation< nvmath::Trafo > *animation)
Set the Animation of this LightSource.

NVSG_API void | setAnimationFrame (size_t frame)
Set the current animation frame.

virtual NVSG_API size_t | getNumberOfFrames () const
Get the number of the attached Animation.

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 | containsLight () const
Overwrite of the query, if this Node contains a LightSource.

virtual NVSG_API const LightSource * | clone () const=0
Interface for creating a new LightSource by copying from this.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another 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.

virtual NVSG_API | ~LightSource ()
Protected destructor to prevent explicit creation.

NVSG_API LightSource & | operator= (const LightSource &rhs)
Assignment operator.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this LightSource.

virtual NVSG_API bool | determineTransparencyContainment () const
Determine the transparency containment state.

virtual NVSG_API void | validateIncarnation () const
Validate the nvutil::Incarnation.

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. The concept is slightly different from other scene graph APIs. Since we have a Switch node that allows turning multiple Nodes on/off, light sources should be handled via this Switch.

Light sources only influence objects under the same Switch/Group or in a subtree under the same Switch/Group.

Example
                        |
     -----------------------------------------
     |                  |                    |
     Ls0               Sw                    NB
                        |
            -----------------------
            |      |       |      |
            Ls1    NA      Ls2    Gr
                                  |
                                 ...
Light source Ls0 lights Switch Sw and in turn all active children of Sw and of course Node NB.
Light source Ls1 lights Node NA and Group Gr and in turn all children of Gr.
And at least light source Ls2 lights Group Gr and in turn all children of Gr.
See also:
DirectedLight, PointLight, SpotLight, Switch

Constructor & Destructor Documentation

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.

virtual NVSG_API ~LightSource ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the LightSource is decremented to zero.
If the LightSource holds an Animation, its reference count is decremented.
See also:
addRef, removeRef

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 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 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

const Animation< nvmath::Trafo > * 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, setAnimationFrame

NVSG_API void setAnimation ( const Animation< nvmath::Trafo > * 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, setAnimationFrame

NVSG_API void setAnimationFrame ( size_t frame )

Set the current animation frame.

Parameters:
frame The frame index of the Animation to use.
Remarks:
The transformation for animation step frame is determined and used as the current.
Note:
The behavior is undefined if frame is greater than or equal to the number of frames in the Animation.
See also:
getAnimation, getNumberOfFrames, setAnimation

size_t getNumberOfFrames ( ) const [inline, virtual]

Get the number of the attached Animation.

Returns:
The number of frames if there is an Animation, otherwise zero.
See also:
setAnimationFrame

Reimplemented from Node.

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 containsLight ( ) const [virtual]

Overwrite of the query, if this Node contains a LightSource.

Returns:
true.
See also:
Node::containsLight

Reimplemented from Node.

virtual NVSG_API const LightSource* clone ( ) const [pure virtual]

Interface for creating a new LightSource by copying from this.

Returns:
A pointer to a constant LightSource
Remarks:
The newly created LightSource is an exact copy of this.

Implements Node.

Implemented in DirectedLight, PointLight, and SpotLight.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with another LightSource.

Parameters:
p | A reference to the constant 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.

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.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this LightSource.

Returns:
A valid, but empty nvmath::Sphere3f.
Remarks:
This function is called by the framework to determine a sphere that completely contains the Node. Because a LightSource does not contribute any geometry to a scene, a valid, but empty, bounding sphere describes it correctly.

Implements Node.

virtual NVSG_API bool determineTransparencyContainment ( ) const [protected, virtual]

Determine the transparency containment state.

Returns:
false.
Remarks:
The framework calls this function if the transparency containment of this Node is requested by Node::containsTransparentGeometry, and this information is flagged as invalid. Because a LightSource does not contribute any geometry to a scene, it can never contain transparent geometries.

Implements Node.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 attache Animation object is requested to continue the validation down the tree hierarchy.
See also:
Animation, Node, nvutil::Incarnation, invalidateIncarnation

Reimplemented from Object.

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 Fri Aug 4 08:38:01 2006 for NVSGSDK by NVIDIA


Member List

LightSource Member List

This is the complete list of members for LightSource, including all inherited members.
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | LightSource | [protected, virtual]
clone() const=0 | LightSource | [pure virtual]
containsCgFx() const | Node | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | LightSource | [virtual]
containsTransparentGeometry() const | Node |
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineTransparencyContainment() const | LightSource | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDiffuseColor() const | LightSource | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames() const | LightSource | [inline, virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCgFxContainment() | Node | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Node | [virtual]
invalidateNumberOfFrames() const | Node | [virtual]
invalidateTransparencyContainment() | Node |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LightSource | [virtual]
isShadowCasting() const | LightSource | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(const Animation< nvmath::Trafo > *animation) | LightSource |
setAnimationFrame(size_t frame) | LightSource |
setAnnotation(const std::string &anno) | Node |
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setHints(unsigned short hints) | Node | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | LightSource | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LightSource() | LightSource | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:01 2006 for NVSGSDK by NVIDIA


TemplateLinearInterpolatedAnimation class Reference

LinearInterpolatedAnimation Class Template Reference

An InterpolatedAnimation 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

virtual const LinearInterpolatedAnimation<
T > * 		clone () const
Create a new LinearInterpolatedAnimation of type T by copying from this.

virtual NVSG_API const T & | operator[] (size_t frame) const
Interpolating random access operator.

LinearInterpolatedAnimation<
T > & 		operator= (const LinearInterpolatedAnimation< T > &rhs)
Assignment operator.

Static Public Member Functions

const LinearInterpolatedAnimation<
T > * 		create ()
Create a LinearInterpolatedAnimation of type T.

const LinearInterpolatedAnimation<
T > * 		createFromBase (const InterpolatedAnimation< T > &rhs)
Create a LinearInterpolatedAnimation of type T by copying from an InterpolatedAnimation of type T.

Protected Member Functions

NVSG_API | LinearInterpolatedAnimation ()
Protected default constructor to prevent explicit creation.

NVSG_API | LinearInterpolatedAnimation (const InterpolatedAnimation< T > &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | LinearInterpolatedAnimation (const LinearInterpolatedAnimation &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~LinearInterpolatedAnimation ()
Protected destructor to prevent explicit creation.

Detailed Description

template<typename T>
class nvsg::LinearInterpolatedAnimation< T >

An InterpolatedAnimation class that performs linear interpolation.

Namespace: nvsg
Remarks:
The LinearInterpolatedAnimation of type T essentially is an InterpolatedAnimation with the constant random access operator being overloaded.
Note:
Currently the only supported types for LinearInterpolatedAnimation are nvmath::Trafo and VNVector.
See also:
InterpolatedAnimation, nvmath::Trafo, VNVector

Constructor & Destructor Documentation

NVSG_API LinearInterpolatedAnimation ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside LinearInterpoatedAnimation<T>::create.
See also:
PrimitiveSet

NVSG_API LinearInterpolatedAnimation ( const InterpolatedAnimation< T > & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant InterpolatedAnimation of type T to use as a base of the new LinearInterpolatedAnimation of type T.
Remarks:
This constructor is never used explicitly, but only inside LinearInterpolatedAnimation<T>::createFromBase.
See also:
InterpolatedAnimation

NVSG_API LinearInterpolatedAnimation ( const LinearInterpolatedAnimation< T > & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant LinearInterpolatedAnimation of type T to copy from.
Remarks:
This constructor is never used explicitly, but only inside LinearInterpolatedAnimation<T>::create.

virtual NVSG_API ~LinearInterpolatedAnimation ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the LinearInterpolatedAnimation of type T is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

const LinearInterpolatedAnimation< T > * create ( ) [static]

Create a LinearInterpolatedAnimation of type T.

Returns:
A pointer to a constant LinearInterpolatedAnimation of type T.

const LinearInterpolatedAnimation< T > * createFromBase ( const InterpolatedAnimation< T > & rhs ) [static]

Create a LinearInterpolatedAnimation of type T by copying from an InterpolatedAnimation of type T.

Parameters:
rhs A reference to the constant InterpolatedAnimation of type T to copy from
Returns:
A pointer to a constant LinearInterpolatedAnimation of type T
Remarks:
All the data from the InterpolatedAnimation of type T rhs is used as the base information for the newly created LinearInterpolatedAnimation of type T. Because there is no additional data in the LinearInterpolatedAnimation of type T, this is the same as using the member function clone().
See also:
InterpolatedAnimation

const LinearInterpolatedAnimation< T > * clone ( ) const [virtual]

Create a new LinearInterpolatedAnimation of type T by copying from this.

Returns:
A pointer to a constant LinearInterpolatedAnimation of type T.
Remarks:
The newly created LinearInterpolatedAnimation or type T is an exact copy of this.

Implements Animation.

virtual NVSG_API const T& operator[] ( size_t frame ) const [virtual]

Interpolating random access operator.

Parameters:
frame The index of the frame of the Animation to get the value for.
Returns:
A reference to the constant value at animation index frame.
Remarks:
This operator calculates the animation value at index frame by linearly interpolating between the two nearest key-frame values. This is then used as the currentValue.
See also:
getCurrentFrame, getCurrentValue

Implements Animation.

LinearInterpolatedAnimation< T > & operator= ( const LinearInterpolatedAnimation< T > & rhs )

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 InterpolatedAnimation of type T.

The documentation for this class was generated from the following file:
  • LinearInterpolatedAnimation.h
Generated on Fri Aug 4 08:38:01 2006 for NVSGSDK by NVIDIA


Member List

LinearInterpolatedAnimation Member List

This is the complete list of members for LinearInterpolatedAnimation, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
Animation(void) | Animation | [protected]
clone() const | LinearInterpolatedAnimation | [virtual]
create() | LinearInterpolatedAnimation | [static]
createFromBase(const InterpolatedAnimation< T > &rhs) | LinearInterpolatedAnimation | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getCurrentFrame(void) const | InterpolatedAnimation | [inline, protected]
getCurrentValue(void) const | InterpolatedAnimation | [inline, protected]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFrame(size_t key) const | InterpolatedAnimation | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getKey(unsigned int frame) const | InterpolatedAnimation | [inline, protected]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | InterpolatedAnimation | [inline, virtual]
getNumberOfKeys(void) const | InterpolatedAnimation | [inline]
getObjectCode() const | Object | [inline]
getValue(size_t key) const | InterpolatedAnimation | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
InterpolatedAnimation(void) | InterpolatedAnimation | [inline, protected]
InterpolatedAnimation(const InterpolatedAnimation &rhs) | InterpolatedAnimation | [inline, protected]
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | InterpolatedAnimation | [inline, virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LinearInterpolatedAnimation() | LinearInterpolatedAnimation | [protected]
LinearInterpolatedAnimation(const InterpolatedAnimation< T > &rhs) | LinearInterpolatedAnimation | [explicit, protected]
LinearInterpolatedAnimation(const LinearInterpolatedAnimation &rhs) | LinearInterpolatedAnimation | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const LinearInterpolatedAnimation< T > &rhs) | LinearInterpolatedAnimation |
nvsg::InterpolatedAnimation::operator=(const InterpolatedAnimation< T > &rhs) | InterpolatedAnimation | [protected]
nvsg::Animation::operator=(const Animation< T > &rhs) | Animation | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
operator[](size_t frame) const | LinearInterpolatedAnimation | [virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setCurrent(size_t key) const | InterpolatedAnimation | [inline, protected]
setCurrent(unsigned int frame, const T &value) const | InterpolatedAnimation | [inline, protected]
setKeyFrame(size_t key, unsigned int frame, const T &value) | InterpolatedAnimation | [inline]
setName(const std::string &name) | Object |
setNumberOfKeys(size_t count) | InterpolatedAnimation | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Animation(void) | Animation | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~InterpolatedAnimation(void) | InterpolatedAnimation | [inline, protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LinearInterpolatedAnimation() | LinearInterpolatedAnimation | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:02 2006 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

virtual NVSG_API const LineAttribute * | clone () const
Create a new LineAttribute by copying from this.

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.

Static Public Member Functions

NVSG_API const LineAttribute * | create ()
Create a LineAttribute.

NVSG_API const LineAttribute * | createFromBase (const PrimitiveAttribute &rhs)
Create a LineAttribute by copying from a PrimitiveAttribute.

Protected Member Functions

NVSG_API | LineAttribute ()
Protected default constructor to prevent explicit creation.

NVSG_API | LineAttribute (const PrimitiveAttribute &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | LineAttribute (const LineAttribute &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~LineAttribute ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside LineAttribute::create.

NVSG_API LineAttribute ( const PrimitiveAttribute & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveAttribute to use as a base of the new LineAttribute
Remarks:
This constructor is never used explicitly, but only inside LineAttribute::createFromBase.
See also:
PrimitiveAttribute

NVSG_API LineAttribute ( const LineAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant LineAttribute to copy from
Remarks:
This constructor is never used explicitly, but only inside LineAttribute::create.

virtual NVSG_API ~LineAttribute ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the LineAttribute is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const LineAttribute* create ( ) [static]

Create a LineAttribute.

Returns:
A pointer to a constant LineAttribute.
Remarks:
A LineAttribute with the following defaults is created:
  • anti aliasing is off
  • stipple factor is one
  • stipple pattern is 0xFFFF, meaning stippling is off
  • width is one

NVSG_API const LineAttribute* createFromBase ( const PrimitiveAttribute & rhs ) [static]

Create a LineAttribute by copying from a PrimitiveAttribute.

Parameters:
rhs A reference to the constant PrimitiveAttribute to copy from
Returns:
A pointer to a constant LineAttribute.
Remarks:
All the data from the PrimitiveAttribute rhs is used as the base information for the newly created LineAttribute. LineAttribute specific data is initialized as if LineAttribute::create would have been called.
See also:
PrimitiveAttribute

virtual NVSG_API const LineAttribute* clone ( ) const [virtual]

Create a new LineAttribute by copying from this.

Returns:
A pointer to a constant LineAttribute.
Remarks:
The newly created LineAttribute is an exact copy of this.

Implements StateAttribute.

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 Fri Aug 4 08:38:03 2006 for NVSGSDK by NVIDIA


Member List

LineAttribute Member List

This is the complete list of members for LineAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | LineAttribute | [virtual]
create() | LineAttribute | [static]
createFromBase(const PrimitiveAttribute &rhs) | LineAttribute | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
getStippleFactor() const | LineAttribute | [inline]
getStipplePattern() const | LineAttribute | [inline]
getWidth() const | LineAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isAntiAliased() const | LineAttribute | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LineAttribute | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LineAttribute() | LineAttribute | [protected]
LineAttribute(const PrimitiveAttribute &rhs) | LineAttribute | [explicit, protected]
LineAttribute(const LineAttribute &rhs) | LineAttribute | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const LineAttribute &rhs) | LineAttribute |
nvsg::PrimitiveAttribute::operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAntiAliasing(bool aa) | LineAttribute | [inline]
setName(const std::string &name) | Object |
setStippleFactor(unsigned short factor) | LineAttribute | [inline]
setStipplePattern(unsigned short pattern) | LineAttribute | [inline]
setWidth(float width) | LineAttribute | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LineAttribute() | LineAttribute | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveAttribute() | PrimitiveAttribute | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:38:03 2006 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

virtual NVSG_API const Lines * | clone () const
Create a new Lines by copying from this.

NVSG_API bool | hasSegments () const
Query if this Lines has segments.

NVSG_API size_t | 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, size_t numSegments)
Set the segments of this Lines.

NVSG_API void | setSegments (size_t pos, const Segment *segments, size_t numSegments)
Set a subset of segments of this Lines.

NVSG_API Lines & | operator= (const Lines &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const Lines * | create ()
Create a Lines.

NVSG_API const Lines * | createFromBase (const IndependentPrimitiveSet &rhs)
Create a Lines by copying from an IndependentPrimitiveSet.

NVSG_API const Lines * | createFromBase (const PrimitiveSet &rhs)
Create a Lines by copying from a PrimitiveSet.

Protected Member Functions

NVSG_API | Lines ()
Protected constructor to prevent explicit creation.

NVSG_API | Lines (const IndependentPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Lines (const PrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Lines (const Lines &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Lines ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Lines::create.

NVSG_API Lines ( const IndependentPrimitiveSet & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to use as a base of the new Lines
Remarks:
This constructor is never used explicitly, but only inside Lines::createFromBase.
See also:
IndependentPrimitiveSet

NVSG_API Lines ( const PrimitiveSet & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveSet to use as a base of the new Lines
Remarks:
This constructor is never used explicitly, but only inside Lines::createFromBase.
See also:
PrimitiveSet

NVSG_API Lines ( const Lines & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Lines to copy from
Remarks:
This constructor is never used explicitly, but only inside Lines::create.

virtual NVSG_API ~Lines ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Lines is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Lines* create ( ) [static]

Create a Lines.

Returns:
A pointer to a constant Lines.
Remarks:
By default, a Lines is empty.

NVSG_API const Lines* createFromBase ( const IndependentPrimitiveSet & rhs ) [static]

Create a Lines by copying from an IndependentPrimitiveSet.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to copy from
Returns:
A pointer to a constant Lines.
Remarks:
All the data from the IndependentPrimitiveSet rhs is used as the base information for the newly created Lines. The indices provided with rhs are interpreted, then, as pairs defining lines.
See also:
IndependentPrimitiveSet

NVSG_API const Lines* createFromBase ( const PrimitiveSet & rhs ) [static]

Create a Lines by copying from a PrimitiveSet.

Parameters:
rhs A reference to the constant PrimitiveSet to copy from
Returns:
A pointer to a constant Lines.
Remarks:
All the data from the PrimitiveSet rhs is used as the base information for the newly created Lines. But there are no line indices provided, so there are no lines in the new Lines object.
See also:
IndependentPrimitiveSet

virtual NVSG_API const Lines* clone ( ) const [virtual]

Create a new Lines by copying from this.

Returns:
A pointer to a constant Lines.
Remarks:
The newly created Lines is an exact copy of this.

Implements IndependentPrimitiveSet.

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

size_t 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,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const Segment * | segments,
 |  | size_t | 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 Fri Aug 4 08:38:04 2006 for NVSGSDK by NVIDIA


Member List

Lines Member List

This is the complete list of members for Lines, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
clone() const | Lines | [virtual]
create() | Lines | [static]
createFromBase(const IndependentPrimitiveSet &rhs) | Lines | [static]
createFromBase(const PrimitiveSet &rhs) | Lines | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfSegments() const | Lines | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getSegments() const | Lines | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
hasSegments() const | Lines | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
Lines() | Lines | [protected]
Lines(const IndependentPrimitiveSet &rhs) | Lines | [explicit, protected]
Lines(const PrimitiveSet &rhs) | Lines | [explicit, protected]
Lines(const Lines &rhs) | Lines | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSegments(const Segment *segments, size_t numSegments) | Lines | [inline]
setSegments(size_t pos, const Segment *segments, size_t numSegments) | Lines | [inline]
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Lines() | Lines | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:04 2006 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

virtual NVSG_API const LineStrips * | clone () const
Create a new LineStrips by copying from this.

NVSG_API LineStrips & | operator= (const LineStrips &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const LineStrips * | create ()
Create a LineStrips.

NVSG_API const LineStrips * | createFromBase (const StrippedPrimitiveSet &rhs)
Create a LineStrips by copying from an StrippedPrimitiveSet.

Protected Member Functions

NVSG_API | LineStrips ()
Protected constructor to prevent explicit creation.

NVSG_API | LineStrips (const StrippedPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | LineStrips (const LineStrips &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~LineStrips ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside LineStrips::create.

NVSG_API LineStrips ( const StrippedPrimitiveSet & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to use as a base of the new LineStrips
Remarks:
This constructor is never used explicitly, but only inside LineStrips::createFromBase.
See also:
StrippedPrimitiveSet

NVSG_API LineStrips ( const LineStrips & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant LineStrips to copy from
Remarks:
This constructor is never used explicitly, but only inside LineStrips::create.

virtual NVSG_API ~LineStrips ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the LineStrips is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const LineStrips* create ( ) [static]

Create a LineStrips.

Returns:
A pointer to a constant LineStrips.
Remarks:
Per default a LineStrips is empty.

NVSG_API const LineStrips* createFromBase ( const StrippedPrimitiveSet & rhs ) [static]

Create a LineStrips by copying from an StrippedPrimitiveSet.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to copy from
Returns:
A pointer to a constant LineStrips.
Remarks:
All the data from the StrippedPrimitiveSet rhs is used as the base information for the newly created LineStrips. The indices provided with rhs are interpreted, then, as a series of connected line segments.
See also:
StrippedPrimitiveSet

virtual NVSG_API const LineStrips* clone ( ) const [virtual]

Create a new LineStrips by copying from this.

Returns:
A pointer to a constant LineStrips.
Remarks:
The newly created LineStrips is an exact copy of this.

Implements StrippedPrimitiveSet.

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 Fri Aug 4 08:38:05 2006 for NVSGSDK by NVIDIA


Member List

LineStrips Member List

This is the complete list of members for LineStrips, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere(void) const | StrippedPrimitiveSet | [protected, virtual]
clone() const | LineStrips | [virtual]
create() | LineStrips | [static]
createFromBase(const StrippedPrimitiveSet &rhs) | LineStrips | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LineStrips() | LineStrips | [protected]
LineStrips(const StrippedPrimitiveSet &rhs) | LineStrips | [explicit, protected]
LineStrips(const LineStrips &rhs) | LineStrips | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setStrips(const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setStrips(size_t pos, const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LineStrips() | LineStrips | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected, virtual]
Generated on Fri Aug 4 08:38:05 2006 for NVSGSDK by NVIDIA


TemplateLockable class Reference

Lockable Class Template Reference

The Lockable class allows to add the SWMRSync feature to a non SWMRSync derived class. More...

#include <Lockable.h>

Inheritance diagram for Lockable:

[legend]
Collaboration diagram for Lockable:

[legend]
List of all members.

Public Member Functions

Lockable (T *ptr)
Constructor.

Lockable (const Lockable< T > &rhs)
Copy constructor performing a deep copy.

~Lockable ()
Destructor simply deletes the internal object.

T * | operator-> ()
Non const access operator.

const T * | operator-> () const
Const access operator.

T & | operator * ()
Non const dereference operator.

const T & | operator * () const
Const dereference operator.

const T * | get () const
Return the pointer to the internal object.

void | reset (T *ptr)
New pointer object. Can be NULL.

Detailed Description

template<typename T>
class nvutil::Lockable< T >

The Lockable class allows to add the SWMRSync feature to a non SWMRSync derived class.

Sample:

 class A
 {
   [...]
   const Lockable<Sphere3f>  m_boundingSphere;
   [...]
 };

 A::A()
 : m_boundingSphere(new Sphere3f())
 {
   [...]
 }

 A::~A()
 {
   Lockable<Sphere3f> & s = beginEdit(m_boundingSphere);
   s.reset(NULL);
   endEdit(s);
 }

 const Sphere3f & A::getBoundingSphere() const
 {
   NVSG_TRACE();
   if ( ! nvmath::isValid( *m_boundingSphere ) )
   {
     Lockable<Sphere3f> & s = beginEdit( m_boundingSphere );
     *s = calculateBoundingSphere();
     endEdit( s );
   }
   return( *m_boundingSphere );
 }

Constructor & Destructor Documentation

Lockable ( T * ptr ) [inline, explicit]

Constructor.

Lockable ( const Lockable< T > & rhs ) [inline, explicit]

Copy constructor performing a deep copy.

~Lockable ( ) [inline]

Destructor simply deletes the internal object.

Member Function Documentation

T* operator-> ( ) [inline]

Non const access operator.

const T* operator-> ( ) const [inline]

Const access operator.

T& operator * ( ) [inline]

Non const dereference operator.

const T& operator * ( ) const [inline]

Const dereference operator.

const T* get ( ) const [inline]

Return the pointer to the internal object.

void reset ( T * ptr ) [inline]

New pointer object. Can be NULL.

Delete the internal pointer object and replace it with the given one.

The documentation for this class was generated from the following file:
  • Lockable.h
Generated on Fri Aug 4 08:40:10 2006 for NVSGSDK by NVIDIA


Member List

Lockable Member List

This is the complete list of members for Lockable, including all inherited members.
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
get() const | Lockable | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
Lockable(T *ptr) | Lockable | [inline, explicit]
Lockable(const Lockable< T > &rhs) | Lockable | [inline, explicit]
operator *() | Lockable | [inline]
operator *() const | Lockable | [inline]
operator->() | Lockable | [inline]
operator->() const | Lockable | [inline]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
reset(T *ptr) | Lockable | [inline]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Lockable() | Lockable | [inline]
Generated on Fri Aug 4 08:40:10 2006 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

virtual NVSG_API const LOD * | clone () const
Create a new LOD by copying from this.

NVSG_API void | setRanges (const float *ranges, size_t 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 size_t | 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 size_t | getLODToUse (const nvmath::Mat44f &modelViewMatrix, float scaleFactor) const
Calculate the LOD level to use.

NVSG_API void | setRangeLock (bool on, size_t rangeNumber)
Lock the range selection to a specific LOD level.

NVSG_API size_t | 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.

Static Public Member Functions

NVSG_API const LOD * | create ()
Create a distance-based level of detail node (LOD).

NVSG_API const LOD * | createFromBase (const Group &rhs)
Create a LOD by copying from a Group.

Protected Member Functions

NVSG_API | LOD (void)
Protected constructor to prevent explicit creation.

NVSG_API | LOD (const Group &rhs)
Protected constructor to prevent explicit creation.

NVSG_API | LOD (const LOD &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~LOD (void)
Protected destructor to prevent explicit creation.

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 ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside LOD::create.

NVSG_API LOD ( const Group & rhs ) [explicit, protected]

Protected constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Group to use as a base of the new LOD
Remarks:
This constructor is never used explicitly, but only inside LOD::createFromBase.
See also:
Group

NVSG_API LOD ( const LOD & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant LOD to copy from
Remarks:
This constructor is never used explicitly, but only inside LOD::create.

virtual NVSG_API ~LOD ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the LOD is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const LOD* create ( ) [static]

Create a distance-based level of detail node (LOD).

Returns:
A pointer to a constant LOD.
Remarks:
A defaul LOD without any children is created. The application must provide different representations that can be used for the different levels of detail.

Reimplemented from Group.

NVSG_API const LOD* createFromBase ( const Group & rhs ) [static]

Create a LOD by copying from a Group.

Parameters:
rhs A reference to the constant PrimitiveAttribute to copy from
Returns:
A pointer to a constant LOD.
Remarks:
All the data from the Group rhs is used as the base information for the newly created LOD. LOD specific data is initialized as if LOD::create was called.
See also:
Group

virtual NVSG_API const LOD* clone ( ) const [virtual]

Create a new LOD by copying from this.

Returns:
A pointer to a constant LOD.
Remarks:
The newly created LOD is an exact copy of this.

Reimplemented from Group.

NVSG_API void setRanges | ( | const float * | ranges,
 |  | size_t | 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 size_t 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 size_t 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,
 |  | size_t | 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, size_t 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 ( size_t 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 size_t 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 reference to the constant 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.

The documentation for this class was generated from the following file:
  • LOD.h
Generated on Fri Aug 4 08:38:06 2006 for NVSGSDK by NVIDIA


Member List

LOD Member List

This is the complete list of members for LOD, including all inherited members.
activateClipPlane(size_t index) | Group | [inline]
addChild(const Node *child, size_t position=0xFFFFFFFF) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | Group | [protected, virtual]
clone() const | LOD | [virtual]
containsCgFx() const | Group | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Group | [virtual]
containsTransparentGeometry() const | Node |
create() | LOD | [static]
createFromBase(const Group &rhs) | LOD | [static]
nvsg::Group::createFromBase(const Node &rhs) | Group | [static]
deactivateClipPlane(size_t index) | Group | [inline]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getCenter() const | LOD |
getChild(size_t position) const | Group | [inline]
getChildPositions(const Node *node, std::vector< size_t > &positions) const | Group |
getClipPlane(size_t index) const | Group | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [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]
getNumberOfFrames() const | Group | [virtual]
getNumberOfParents() const | Node | [inline]
getNumberOfRanges() const | LOD |
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getRangeLock() const | LOD |
getRanges() const | LOD |
Group() | Group | [protected]
Group(const Node &rhs) | Group | [explicit, protected]
Group(const Group &rhs) | Group | [protected]
hasChild(const Node *node) const | Group |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const Node *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Group | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Group | [virtual]
invalidateNumberOfFrames() const | Group | [virtual]
invalidateTransparencyContainment() | Node |
isClipPlaneActive(size_t index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | LOD | [virtual]
isRangeLockEnabled() const | LOD |
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LOD(void) | LOD | [protected]
LOD(const Group &rhs) | LOD | [explicit, protected]
LOD(const LOD &rhs) | LOD | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
postAddChild(size_t position) | Group | [protected, virtual]
postRemoveChild(size_t position) | Group | [protected, virtual]
preAddChild(size_t position) | Group | [protected, virtual]
preRemoveChild(size_t position) | Group | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeChild(const Node *child) | Group |
removeChild(size_t position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceChild(const Node *newChild, const Node *oldChild) | Group |
replaceChild(const Node *newChild, size_t position) | Group |
setAnnotation(const std::string &anno) | Node |
setCenter(const nvmath::Vec3f &center) | LOD |
setClipPlane(size_t index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
setRangeLock(bool on, size_t rangeNumber) | LOD |
setRanges(const float *ranges, size_t count) | LOD |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Group | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Group() | Group | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LOD(void) | LOD | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:07 2006 for NVSGSDK by NVIDIA


LODCombineTraverser Class Reference

Traverser that combines LODS with the same ranges under one Group or Transform to a single one. More...

#include <LODCombineTraverser.h>

Inheritance diagram for LODCombineTraverser:

[legend]
Collaboration diagram for LODCombineTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | LODCombineTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~LODCombineTraverser (void)
Protected destructor to prevent instantiation of a GeoNodeCombineTraverser on stack.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Combine all compatible LOD objects directly underneath this AnimatedTransform.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Combine all compatible LOD objects directly underneath this Billboard.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Combine all compatible LOD objects directly underneath this Group.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Combine all compatible LOD objects directly underneath this Transform.

Detailed Description

Traverser that combines LODS with the same ranges under one Group or Transform to a single one.

Constructor & Destructor Documentation

NVSG_API LODCombineTraverser ( void )

Constructor.

virtual NVSG_API ~LODCombineTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a GeoNodeCombineTraverser on stack.

Member Function Documentation

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Combine all compatible LOD objects directly underneath this AnimatedTransform.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform.

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Combine all compatible LOD objects directly underneath this Billboard.

Parameters:
p Points to the currently visited Billboard object.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Combine all compatible LOD objects directly underneath this Group.

Parameters:
p Points to the currently visited Group object.

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Combine all compatible LOD objects directly underneath this Transform.

Parameters:
p Points to the currently visited Transform object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • LODCombineTraverser.h
Generated on Fri Aug 4 08:39:22 2006 for NVSGSDK by NVIDIA


Member List

LODCombineTraverser Member List

This is the complete list of members for LODCombineTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | OptimizeTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | LODCombineTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | LODCombineTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | LODCombineTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | LODCombineTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
LODCombineTraverser(void) | LODCombineTraverser |
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~LODCombineTraverser(void) | LODCombineTraverser | [protected, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:22 2006 for NVSGSDK by NVIDIA


LODEliminateTraverser Class Reference

Traverser that eliminates unneccessary LODs. More...

#include <LODEliminateTraverser.h>

Inheritance diagram for LODEliminateTraverser:

[legend]
Collaboration diagram for LODEliminateTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | LODEliminateTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~LODEliminateTraverser (void)
Protected destructor to prevent instantiation of a LODEliminateTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
If the root node is a LOD with a single child, it is removed.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
If the AnimatedTransform holds LODS with one child, they are replaced by their respective child.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
If the Billboard holds LODs with one child, they are replaced by their respective child.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
If the Group holds LODs with one child, they are replaced by their respective child.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
If the LOD holds LODs with one child, they are replaced by their respective child.

virtual NVSG_API void | handleSwitch (const nvsg::Switch *p)
If the Switch holds LODs with one child, they are replaced by their respective child.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
If the Transform holds LODs with one child, they are replaced by their respective child.

Detailed Description

Traverser that eliminates unneccessary LODs.

A LOD is unneccessary if it holds only one child (and no ranges). Thent the LOD can simply be replaced by it's child.

Constructor & Destructor Documentation

NVSG_API LODEliminateTraverser ( void )

Constructor.

virtual NVSG_API ~LODEliminateTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a LODEliminateTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * scene ) [protected, virtual]

If the root node is a LOD with a single child, it is removed.

Parameters:
scene Scene to traverse and handle

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

If the AnimatedTransform holds LODS with one child, they are replaced by their respective child.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform.

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

If the Billboard holds LODs with one child, they are replaced by their respective child.

Parameters:
p Points to the currently visited Billboard object.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

If the Group holds LODs with one child, they are replaced by their respective child.

Parameters:
p Points to the currently visited Group object.

Reimplemented from Traverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

If the LOD holds LODs with one child, they are replaced by their respective child.

Parameters:
p Points to the currently visited LOD object.

Reimplemented from Traverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

If the Switch holds LODs with one child, they are replaced by their respective child.

Parameters:
p Points to the currently visited Switch object.

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

If the Transform holds LODs with one child, they are replaced by their respective child.

Parameters:
p Points to the currently visited Transform object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • LODEliminateTraverser.h
Generated on Fri Aug 4 08:39:23 2006 for NVSGSDK by NVIDIA


Member List

LODEliminateTraverser Member List

This is the complete list of members for LODEliminateTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | LODEliminateTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | LODEliminateTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | LODEliminateTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | LODEliminateTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | LODEliminateTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | LODEliminateTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | LODEliminateTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
LODEliminateTraverser(void) | LODEliminateTraverser |
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~LODEliminateTraverser(void) | LODEliminateTraverser | [protected, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:23 2006 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 Fri Aug 4 08:40:10 2006 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 Fri Aug 4 08:40:10 2006 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 Fri Aug 4 08:39:58 2006 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 Fri Aug 4 08:39:58 2006 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 const Map * | clone () const=0
Interface for creating a new Map by copying from this.

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 (size_t width, size_t height, size_t bitsPerPixel, unsigned char *data)
Protected constructor to prevent explicit creation.

NVSG_API | Map (const Map &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Map ()
Protected destructor to prevent explicit creation.

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

NVSG_API Map | ( | size_t | width,
 |  | size_t | height,
 |  | size_t | bitsPerPixel,
 |  | unsigned char * | data
 | ) | [protected]

Protected constructor to prevent explicit creation.

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:
The constructor allocates height*((width*bpp+7)/8) bytes to hold the map data and copies as many bytes from data.

NVSG_API Map ( const Map & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Remarks:
The complete map data is copied over from rhs.

virtual NVSG_API ~Map ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Map is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

virtual NVSG_API const Map* clone ( ) const [pure virtual]

Interface for creating a new Map by copying from this.

Returns:
A pointer to a constant Map.
Remarks:
The newly created Map is an exact copy of this.

Implemented in Bitmap.

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

The documentation for this class was generated from the following file:
  • Map.h
Generated on Fri Aug 4 08:38:07 2006 for NVSGSDK by NVIDIA


Member List

Map Member List

This is the complete list of members for Map, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const=0 | Map | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getData() const | Map | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHeight() const | Map | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
getWidth() const | Map | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
Map(size_t width, size_t height, size_t bitsPerPixel, unsigned char *data) | Map | [protected]
Map(const Map &rhs) | Map | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Map() | Map | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:07 2006 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

virtual NVSG_API const MapArray * | clone () const
Create a new MapArray by copying from this.

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 size_t | getSpacing () const
Get the spacing between consecutive Map objects.

NVSG_API void | setSpacing (size_t 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 size_t | getNumberOfMaps () const
Get the number of Map objects in this MapArray.

NVSG_API const Map * | getMap (size_t index) const
Get a pointer to the constant Map at the specified index.

NVSG_API size_t | getIndexOfMap (const Map *map) const
Get the index of a Map in this MapArray.

NVSG_API void | addMap (const Map *map)
Add a Map to the end of the MapArray.

NVSG_API void | insertMap (size_t index, const Map *map)
Insert a Map in front of the specified index.

NVSG_API void | replaceMap (size_t index, const Map *map)
Replace the Map at the specified index.

NVSG_API void | removeMap (size_t index)
Remove the Map at the specified index.

NVSG_API void | clear (void)
Clear the MapArray.

NVSG_API void | getEntrySize (size_t &width, size_t &height) const
Get the maximal width and height of the Map objects.

virtual NVSG_API void | getSize (size_t &width, size_t &height) const
Get the overall size of the MapArray.

virtual NVSG_API const Map * | pickMap (int x, int y) const
Get the Map being at the specified raster position.

Static Public Member Functions

NVSG_API const MapArray * | create ()
Create a MapArray.

Protected Member Functions

NVSG_API | MapArray ()
Protected default constructor to prevent explicit creation.

NVSG_API | MapArray (const MapArray &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~MapArray ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside MapArray::create.

NVSG_API MapArray ( const MapArray & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant MapArray to copy from
Remarks:
This constructor is never used explicitly, but only inside MapArray::create.

virtual NVSG_API ~MapArray ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MapArray is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const MapArray* create ( ) [static]

Create a MapArray.

Returns:
A pointer to a constant MapArray.
Remarks:
The MapArray is created with the following defaults:
  • aligned along the lower base line (MA_LOWER)
  • orientation is vertical (MO_VERTICAL)
  • spacing is one pixel (1)
  • traversal direction is from low index to high index (MTD_LOW_TO_HIGH)

virtual NVSG_API const MapArray* clone ( ) const [virtual]

Create a new MapArray by copying from this.

Returns:
A pointer to a constant MapArray.
Remarks:
The newly created MapArray is an exact copy of this.

Implements MapObject.

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

size_t 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 ( size_t 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

size_t 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

const Map * getMap ( size_t index ) const [inline]

Get a pointer to the constant Map at the specified index.

Parameters:
index Index of the Map to get.
Returns:
A pointer to the constant Map at the specified index in the MapArray.
Note:
The behaviour is undefined, if index is larger than or equal to the number of Map objects in this MapArray.
See also:
addMap, getNumberOfMaps, insertMap, removeMap, replaceMap

size_t getIndexOfMap ( const Map * map ) const [inline]

Get the index of a Map in this MapArray.

Parameters:
map A pointer to the constant Map to get index for.
Returns:
The index of map in this MapArray, or (-1) if map is not part of this MapArray.
See also:
getMap, pickMap

void addMap ( const Map * map ) [inline]

Add a Map to the end of the MapArray.

Parameters:
map A pointer to the constant Map to add.
Remarks:
The reference count of map is incremented.
See also:
getMap, getNumberOfMaps, insertMap, replaceMap, removeMap

void insertMap | ( | size_t | index,
 |  | const Map * | map
 | ) | [inline]

Insert a Map in front of the specified index.

Parameters:
index | Index to insert a Map before.
map | A pointer to the constant Map to insert.
Remarks:
The reference count of map is incremented.
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, replaceMap, removeMap

void replaceMap | ( | size_t | index,
 |  | const Map * | map
 | ) | [inline]

Replace the Map at the specified index.

Parameters:
index | Index to replace the Map at.
map | A pointer to the constant Map to replace with.
Remarks:
The reference count of map is incremented, and the reference count of the Map 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 ( size_t 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 | ( | size_t & | width,
 |  | size_t & | 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 | ( | size_t & | width,
 |  | size_t & | 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 const Map* pickMap | ( | int | x,
 |  | int | y
 | ) | const [virtual]

Get the Map 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 the constant Map being at the specified raster position, or NULL if there is none.
Remarks:
This function determines the Map 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 Map objects are considered to be of equal height; for a vertically oriented MapArray, the Map objects are considered to be of equal width. If the position is in the spacing between two Map objects, or outside of the overall size of the MapArray, NULL is returned.
See also:
getEntrySize, getSize, getMap

Implements MapObject.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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:
  • MapArray.h
Generated on Fri Aug 4 08:38:08 2006 for NVSGSDK by NVIDIA


Member List

MapArray Member List

This is the complete list of members for MapArray, including all inherited members.
addMap(const Map *map) | MapArray | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clear(void) | MapArray |
clone() const | MapArray | [virtual]
create() | MapArray | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAlignment() const | MapArray | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getEntrySize(size_t &width, size_t &height) const | MapArray |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIndexOfMap(const Map *map) const | MapArray | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getLowerLeft(int &x, int &y) const | MapObject |
getMap(size_t 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(size_t &width, size_t &height) const | MapArray | [virtual]
getSpacing() const | MapArray | [inline]
getTraversalDirection() const | MapArray | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
insertMap(size_t index, const Map *map) | MapArray | [inline]
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
MapArray() | MapArray | [protected]
MapArray(const MapArray &rhs) | MapArray | [protected]
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
pickMap(int x, int y) const | MapArray | [virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeMap(size_t index) | MapArray | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceMap(size_t index, const Map *map) | MapArray | [inline]
setAlignment(MapAlignment alignment) | MapArray | [inline]
setName(const std::string &name) | Object |
setOrientation(MapOrientation orientation) | MapArray | [inline]
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
setSpacing(size_t spacing) | MapArray | [inline]
setTraversalDirection(MapTraversalDirection direction) | MapArray | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | MapArray | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MapArray() | MapArray | [protected, virtual]
~MapObject(void) | MapObject | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:08 2006 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

virtual NVSG_API const MapElement * | clone () const
Create a new MapElement by copying from this.

NVSG_API const Map * | getMap () const
Get a pointer to the constant Map.

virtual NVSG_API void | getSize (size_t &width, size_t &height) const
Get the overall size of the MapElement.

virtual NVSG_API const Map * | pickMap (int x, int y) const
Get the Map being at the specified raster position.

Static Public Member Functions

NVSG_API const MapElement * | create (const Map *m)
Create a MapElement.

Protected Member Functions

NVSG_API | MapElement (const Map *m)
Protected default constructor to prevent explicit creation.

NVSG_API | MapElement (const MapElement &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~MapElement ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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 ( const Map * m ) [protected]

Protected default constructor to prevent explicit creation.

Parameters:
m A pointer to the constant Map to be used by this MapElement.
Remarks:
This constructor is never used explicitly, but only inside MapElement::create.

NVSG_API MapElement ( const MapElement & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant MapElement to copy from
Remarks:
This constructor is never used explicitly, but only inside MapElement::create.

virtual NVSG_API ~MapElement ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MapElement is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const MapElement* create ( const Map * m ) [static]

Create a MapElement.

Parameters:
m A pointer to the constant Map to be held by this MapElement.
Returns:
A pointer to a constant MapElement.
Remarks:
The reference count of the Map m is incremented. The Map of the MapElement can't be removed or changed.

virtual NVSG_API const MapElement* clone ( ) const [virtual]

Create a new MapElement by copying from this.

Returns:
A pointer to a constant MapElement.
Remarks:
The newly created MapElement is an exact copy of this.

Implements MapObject.

const Map * getMap ( ) const [inline]

Get a pointer to the constant Map.

Returns:
A pointer to the constant Map of this MapElement.
See also:
pickMap

virtual NVSG_API void getSize | ( | size_t & | width,
 |  | size_t & | 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.

const Map * pickMap | ( | int | x,
 |  | int | y
 | ) | const [inline, virtual]

Get the Map 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 the constant Map being at the specified raster position, or NULL if there is none.
Remarks:
This functions determines if the Map of this MapElement is at the specified raster position (x, y). If it is, a pointer to the constant Map is returned, otherwise NULL.
See also:
getMap

Implements MapObject.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 Map is requested to continue validation down the tree hierarchy. Incarnation

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • MapElement.h
Generated on Fri Aug 4 08:38:09 2006 for NVSGSDK by NVIDIA


Member List

MapElement Member List

This is the complete list of members for MapElement, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | MapElement | [virtual]
create(const Map *m) | MapElement | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
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(size_t &width, size_t &height) const | MapElement | [virtual]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
MapElement(const Map *m) | MapElement | [protected]
MapElement(const MapElement &rhs) | MapElement | [protected]
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
pickMap(int x, int y) const | MapElement | [inline, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | MapElement | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MapElement() | MapElement | [protected, virtual]
~MapObject(void) | MapObject | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:09 2006 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

virtual NVSG_API const MapList * | clone (void) const
Create a new MapList by copying from this.

NVSG_API size_t | getNumberOfMapObjects (void) const
Get the number of MapObject objects in this MapList.

NVSG_API const MapObject * | getMapObject (size_t index) const
Get a pointer to the constant MapObject at the specified index.

NVSG_API void | addMapObject (const MapObject *mo)
Add a MapObject to the end of the MapList.

NVSG_API void | insertMapObject (size_t index, const MapObject *mo)
Insert a MapObject in front of the specified index.

NVSG_API void | replaceMapObject (size_t index, const MapObject *mo)
Replace the MapObject at the specified index.

NVSG_API void | removeMapObject (size_t index)
Remove the MapObject at the specified index.

NVSG_API void | clear (void)
Clear the MapList.

NVSG_API const Map * | pickMap (int x, int y, size_t *index=NULL) const
Get the Map located at the specified raster position.

Static Public Member Functions

NVSG_API const MapList * | create (void)
Create a MapList.

Protected Member Functions

NVSG_API | MapList (void)
Protected default constructor to prevent explicit creation.

NVSG_API | MapList (const MapList &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~MapList (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation (void) 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 ( void ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside MapList::create.

NVSG_API MapList ( const MapList & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant MapList to copy from
Remarks:
This constructor is never used explicitly, but only inside MapList::create.

virtual NVSG_API ~MapList ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MapList is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const MapList* create ( void ) [static]

Create a MapList.

Returns:
A pointer to a constant MapList.
Remarks:
A newly created MapList is empty.

virtual NVSG_API const MapList* clone ( void ) const [virtual]

Create a new MapList by copying from this.

Returns:
A pointer to a constant MapList.
Remarks:
The newly created MapList is an exact copy of this.

size_t getNumberOfMapObjects ( void ) const [inline]

Get the number of MapObject objects in this MapList.

Returns:
The number of contained MapObject objects.
See also:
addMapObject, getMapObject

const MapObject * getMapObject ( size_t 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 ( const MapObject * 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 | ( | size_t | index,
 |  | const MapObject * | 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 | ( | size_t | index,
 |  | const MapObject * | 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 ( size_t 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 const Map* pickMap | ( | int | x,
 |  | int | y,
 |  | size_t * | index = NULL
 | ) | const

Get the Map located at the specified raster position.

Parameters:
x | Horizontal raster coordinate to use for getting the Map.
y | Vertical raster coordinate to use for getting the Map.
index | Optional pointer to get the index of the MapObject that holds the picked Map.
Returns:
A pointer to the constant Map being at the specified raster position, or NULL if there is none. If a Map is picked and index is not NULL, it returns the index of the MapObject holding the picked Map.
Remarks:
This function determines the Map of this MapList at the specified raster position (x, y), if any. It asks each of its MapObject objects if it has a Map at the specified position, and if so, that Map is returned. If index is not NULL, the index of the MapObject holding that Map is returned there, too.
See also:
getMapObject, getNumberOfMapObjects

virtual NVSG_API void validateIncarnation ( void ) const [protected, 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 Fri Aug 4 08:38:10 2006 for NVSGSDK by NVIDIA


Member List

MapList Member List

This is the complete list of members for MapList, including all inherited members.
addMapObject(const MapObject *mo) | MapList | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clear(void) | MapList |
clone(void) const | MapList | [virtual]
create(void) | MapList | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getMapObject(size_t index) const | MapList | [inline]
getName() const | Object |
getNumberOfMapObjects(void) const | MapList | [inline]
getObjectCode() const | Object | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
insertMapObject(size_t index, const MapObject *mo) | MapList | [inline]
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
MapList(void) | MapList | [protected]
MapList(const MapList &rhs) | MapList | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
pickMap(int x, int y, size_t *index=NULL) const | MapList |
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeMapObject(size_t index) | MapList | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceMapObject(size_t index, const MapObject *mo) | MapList | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | MapList | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MapList(void) | MapList | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:10 2006 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

virtual NVSG_API const MapMatrix * | clone (void) const
Create a new MapMatrix by copying from this.

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 size_t | getSpacing (MapOrientation orientation) const
Get the spacing between consecutive Map objects along the orientation.

NVSG_API void | setSpacing (MapOrientation orientation, size_t 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 size_t | 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 (size_t col)
Insert an empty column of Map objects in front of column col.

NVSG_API void | removeColumn (size_t col)
Remove the column col of Map objects.

NVSG_API size_t | getNumberOfMaps (size_t col) const
Get the number of Map objects in the column col.

NVSG_API const Map * | getMap (size_t col, size_t row) const
Get a pointer to the constant Map at the specified position.

NVSG_API bool | getIndexOfMap (const Map *map, size_t &col, size_t &row) const
Get the index of a Map in this MapMatrix.

NVSG_API void | addMap (size_t col, const Map *map)
Add a Map at the end of the column col.

NVSG_API void | insertMap (size_t col, size_t row, const Map *map)
Insert a Map in the column col in front of index row.

NVSG_API void | replaceMap (size_t col, size_t row, const Map *map)
Replace the Map in the column col at index row.

NVSG_API void | removeMap (size_t col, size_t row)
Remove the Map in the column col at index row.

NVSG_API void | getEntrySize (size_t &width, size_t &height) const
Get the maximal width and height of the Map objects.

virtual NVSG_API void | getSize (size_t &width, size_t &height) const
Get the overall size of the MapMatrix.

virtual NVSG_API const Map * | pickMap (int x, int y) const
Get the Map located at the specified raster position.

Static Public Member Functions

NVSG_API const MapMatrix * | create (void)
Create a MapMatrix.

Protected Member Functions

NVSG_API | MapMatrix (void)
Protected default constructor to prevent explicit creation.

NVSG_API | MapMatrix (const MapMatrix &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~MapMatrix (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation (void) const
Validate the Incarnation.

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 ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside MapMatrix::create.

NVSG_API MapMatrix ( const MapMatrix & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant MapMatrix to copy from
Remarks:
This constructor is never used explicitly, but only inside MapMatrix::create.

virtual NVSG_API ~MapMatrix ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MapMatrix is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const MapMatrix* create ( void ) [static]

Create a MapMatrix.

Returns:
A pointer to a constant MapMatrix.
Remarks:
The MapMatrix is created with the following defaults in both directions:
  • aligned along the lower base line (MA_LOWER)
  • spacing is one pixel (1)
  • traversal direction from low index to high index (MTD_LOW_TO_HIGH)

virtual NVSG_API const MapMatrix* clone ( void ) const [virtual]

Create a new MapMatrix by copying from this.

Returns:
A pointer to a constant MapMatrix.
Remarks:
The newly created MapMatrix is an exact copy of this.

Implements MapObject.

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

size_t 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,
 |  | size_t | 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

size_t 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 ( size_t 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 ( size_t 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

size_t getNumberOfMaps ( size_t 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

const Map * getMap | ( | size_t | col,
 |  | size_t | row
 | ) | const [inline]

Get a pointer to the constant Map at the specified position.

Parameters:
col | Index of the column.
row | Index of the row in column col.
Returns:
A pointer to the constant Map object 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 Map objects in the column col.
See also:
addMap, getIndexOfMap, getNumberOfColumns, getNumberOfMaps, pickMap

NVSG_API bool getIndexOfMap | ( | const Map * | map,
 |  | size_t & | col,
 |  | size_t & | row
 | ) | const

Get the index of a Map in this MapMatrix.

Parameters:
map | A pointer to the constant Map to use for getting the index.
col | A reference to get the column, where map is in.
row | A reference to get the row, where map is in.
Returns:
true, if map is part of this MapMatrix, otherwise false.
See also:
getMap, getNumberOfColumns, getNumberOfMaps, pickMap

void addMap | ( | size_t | col,
 |  | const Map * | map
 | ) | [inline]

Add a Map at the end of the column col.

Parameters:
col | Index of the column to add the Map to.
map | A pointer to the constant Map to add.
Remarks:
The reference count of map 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 | ( | size_t | col,
 |  | size_t | row,
 |  | const Map * | map
 | ) | [inline]

Insert a Map in the column col in front of index row.

Parameters:
col | Index of the column to insert the Map into.
row | Index of the row in the column col to insert the Map before.
map | A pointer to the constant Map to insert.
Remarks:
The reference count of map 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 Map objects in the column col.
See also:
addMap, getNumberOfColumns, getNumberOfMaps, removeMap, replaceMap

void replaceMap | ( | size_t | col,
 |  | size_t | row,
 |  | const Map * | map
 | ) | [inline]

Replace the Map in the column col at index row.

Parameters:
col | Index of the column to replace the Map in.
row | Index of the row in the column col to replace the Map at.
map | A pointer to the constant Map to replace with.
Remarks:
The reference count of map is incremented, and the reference count of the Map 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 Map objects in the column col.
See also:
addMap, getNumberOfColumns, getNumberOfMaps, insertMap, removeMap

void removeMap | ( | size_t | col,
 |  | size_t | 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 | ( | size_t & | width,
 |  | size_t & | 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 | ( | size_t & | width,
 |  | size_t & | 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 const Map* pickMap | ( | int | x,
 |  | int | y
 | ) | const [virtual]

Get the Map located at the specified raster position.

Parameters:
x | Horizontal raster coordinate to use for getting the Map.
y | Vertical raster coordinate to use for getting the Map.
Returns:
A pointer to the constant Map located at the specified raster position, or NULL if there is none.
Remarks:
This function determines the Map of this MapMatrix at the specified raster position (x, y), if any. It takes into account the position, alignment, direction, and spacing. Each Map is considered to be the size of the largest Map in this MapMatrix. If the position is in the spacing between two Map objects, or outside of the overall size of the MapMatrix, NULL is returned.
See also:
getEntrySize, getSize, getMap

Implements MapObject.

virtual NVSG_API void validateIncarnation ( void ) const [protected, 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:
  • MapMatrix.h
Generated on Fri Aug 4 08:38:11 2006 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(size_t col, const Map *map) | MapMatrix | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone(void) const | MapMatrix | [virtual]
create(void) | MapMatrix | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAlignment(MapOrientation orientation) const | MapMatrix | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getEntrySize(size_t &width, size_t &height) const | MapMatrix |
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getIndexOfMap(const Map *map, size_t &col, size_t &row) const | MapMatrix |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getLowerLeft(int &x, int &y) const | MapObject |
getMap(size_t col, size_t row) const | MapMatrix | [inline]
getName() const | Object |
getNumberOfColumns(void) const | MapMatrix | [inline]
getNumberOfMaps(size_t col) const | MapMatrix | [inline]
getObjectCode() const | Object | [inline]
getPosition(int &x, int &y) const | MapObject | [inline]
getRelation(void) const | MapObject | [inline]
getSize(size_t &width, size_t &height) const | MapMatrix | [virtual]
getSpacing(MapOrientation orientation) const | MapMatrix | [inline]
getTraversalDirection(MapOrientation orientation) const | MapMatrix | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
insertEmptyColumn(size_t col) | MapMatrix | [inline]
insertMap(size_t col, size_t row, const Map *map) | MapMatrix | [inline]
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
MapMatrix(void) | MapMatrix | [protected]
MapMatrix(const MapMatrix &rhs) | MapMatrix | [protected]
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
pickMap(int x, int y) const | MapMatrix | [virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeColumn(size_t col) | MapMatrix |
removeMap(size_t col, size_t row) | MapMatrix | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceMap(size_t col, size_t row, const Map *map) | MapMatrix | [inline]
setAlignment(MapOrientation orientation, MapAlignment alignment) | MapMatrix | [inline]
setName(const std::string &name) | Object |
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
setSpacing(MapOrientation orientation, size_t spacing) | MapMatrix | [inline]
setTraversalDirection(MapOrientation orientation, MapTraversalDirection direction) | MapMatrix | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | MapMatrix | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MapMatrix(void) | MapMatrix | [protected, virtual]
~MapObject(void) | MapObject | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:11 2006 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 const MapObject * | clone (void) const=0
Interface for creating a new MapObject by copying from this.

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 (size_t &width, size_t &height) const=0
Interface to get the overall size of the MapObject.

virtual NVSG_API const Map * | pickMap (int x, int y) const=0
Interface to get a Map 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.

virtual NVSG_API | ~MapObject (void)
Protected destructor 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

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.

virtual NVSG_API ~MapObject ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MapObject is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

virtual NVSG_API const MapObject* clone ( void ) const [pure virtual]

Interface for creating a new MapObject by copying from this.

Returns:
A pointer to a constant MapObject.
Remarks:
The newly created MapObject is an exact copy of this.

Implemented in MapArray, MapElement, and MapMatrix.

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 | ( | size_t & | width,
 |  | size_t & | 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 const Map* pickMap | ( | int | x,
 |  | int | y
 | ) | const [pure virtual]

Interface to get a Map at a specified raster position.

Parameters:
x | Horizontal raster coordinate for the Map to get.
y | Vertical raster coordinate for the Map to get.
Returns:
A pointer to the constant Map being at the specified raster position, or NULL if there is none.

Implemented in MapArray, MapElement, and MapMatrix.

The documentation for this class was generated from the following file:
  • MapObject.h
Generated on Fri Aug 4 08:38:12 2006 for NVSGSDK by NVIDIA


Member List

MapObject Member List

This is the complete list of members for MapObject, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone(void) const=0 | MapObject | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
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(size_t &width, size_t &height) const=0 | MapObject | [pure virtual]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
MapObject(void) | MapObject | [protected]
MapObject(const MapObject &rhs) | MapObject | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
pickMap(int x, int y) const=0 | MapObject | [pure virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setPosition(int x, int y) | MapObject | [inline]
setRelation(MapRelation relation) | MapObject | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MapObject(void) | MapObject | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:12 2006 for NVSGSDK by NVIDIA


Mat33f Class Reference

Two dimensional matrix of three times three floats. More...

#include <Mat33f.h>

Inheritance diagram for Mat33f:

[legend]
Collaboration diagram for Mat33f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Mat33f (void)
Default constructor.

NVSG_API | Mat33f (float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)
Constructor using 9 floats.

NVSG_API | Mat33f (const Vec3f &row0, const Vec3f &row1, const Vec3f &row2)
Constructor using three row vectors.

NVSG_API | Mat33f (const Vec3f &axis, float rad)
Constructor using a normalized rotation axis and angle (in radians).

NVSG_API | Mat33f (const Quatf &quat)
Constructor using a normalized quaternion.

NVSG_API | Mat33f (const Matnnf< 3 > &m)
Copy constructor.

NVSG_API void | set (const Vec3f &row0, const Vec3f &row1, const Vec3f &row2)
Set the matrix with three row vectors.

Related Functions

(Note that these are not member functions.)

NVSG_API void | decompose (const Mat33f &mat, Quatf &orientation, Vec3f &scaling, Quatf &scaleOrientation)
float | determinant (const Mat33f &mat)
bool | isRotation (const Mat33f &mat, float epsilon=FLT_EPSILON)

Detailed Description

Two dimensional matrix of three times three floats.

A Mat33f can represent a rotation plus scaling in 3D. To also represent a translation, you need to use a Mat44f.

Constructor & Destructor Documentation

NVSG_API Mat33f ( void )

Default constructor.

For performance reasons no initialization is performed.

NVSG_API Mat33f | ( | float | a00,
 |  | float | a01,
 |  | float | a02,
 |  | float | a10,
 |  | float | a11,
 |  | float | a12,
 |  | float | a20,
 |  | float | a21,
 |  | float | a22
 | ) |

Constructor using 9 floats.

The 9 floats are used as the matrix elements. No normalization is performed.

NVSG_API Mat33f | ( | const Vec3f & | row0,
 |  | const Vec3f & | row1,
 |  | const Vec3f & | row2
 | ) |

Constructor using three row vectors.

The three vectors are used as the three rows of the matrix. No normalization is performed.

NVSG_API Mat33f | ( | const Vec3f & | axis,
 |  | float | rad
 | ) |

Constructor using a normalized rotation axis and angle (in radians).

This results in a pure rotation matrix.

Parameters:
axis | rotation axis
rad | angle to rotate (in radians)

NVSG_API Mat33f ( const Quatf & quat )

Constructor using a normalized quaternion.

This results in a pure rotation matrix.

Parameters:
quat quaternion for rotation

NVSG_API Mat33f ( const Matnnf< 3 > & m )

Copy constructor.

Parameters:
m matrix to copy from

Member Function Documentation

void set | ( | const Vec3f & | row0,
 |  | const Vec3f & | row1,
 |  | const Vec3f & | row2
 | ) | [inline]

Set the matrix with three row vectors.

Friends And Related Function Documentation

NVSG_API void decompose | ( | const Mat33f & | mat,
 |  | Quatf & | orientation,
 |  | Vec3f & | scaling,
 |  | Quatf & | scaleOrientation
 | ) | [related]

Decompose the non-singular Mat33f mat into scaling, orientation, and scaleOrientation

Parameters:
mat | matrix to decompose
orientation | rotational part
scaling | scaling factors
scaleOrientation | scaling rotation

float determinant ( const Mat33f & mat ) [related]

Determine the determinant of a Mat33f.

Returns:
determinant of the Mat33f
Parameters:
mat matrix to determine determinant of

bool isRotation | ( | const Mat33f & | mat,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Mat33f is a rotation.
A Mat33f is a rotation if it is normalized, orthogonal, and the determinant differs less than epsilon from one.

Returns:
true if the mat is a rotation, otherwise false
Parameters:
mat | matrix to test
epsilon | optional epsilon

The documentation for this class was generated from the following file:
  • Mat33f.h
Generated on Fri Aug 4 08:37:21 2006 for NVSGSDK by NVIDIA


Member List

Mat33f Member List

This is the complete list of members for Mat33f, including all inherited members.
decompose(const Mat33f &mat, Quatf &orientation, Vec3f &scaling, Quatf &scaleOrientation) | Mat33f | [related]
determinant(const Mat33f &mat) | Mat33f | [related]
getPtr(void) const | Matnnf< 3 > |
invert(void) | Matnnf< 3 > |
isRotation(const Mat33f &mat, float epsilon=FLT_EPSILON) | Mat33f | [related]
Mat33f(void) | Mat33f |
Mat33f(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22) | Mat33f |
Mat33f(const Vec3f &row0, const Vec3f &row1, const Vec3f &row2) | Mat33f |
Mat33f(const Vec3f &axis, float rad) | Mat33f |
Mat33f(const Quatf &quat) | Mat33f |
Mat33f(const Matnnf< 3 > &m) | Mat33f |
Matnnf(void) | Matnnf< 3 > |
operator *(float f) const | Matnnf< 3 > |
operator *(const Vecnf< n > &v) const | Matnnf< 3 > |
operator *=(float f) | Matnnf< 3 > |
operator *=(const Matnnf< n > &m) | Matnnf< 3 > |
operator!=(const Matnnf< n > &m) const | Matnnf< 3 > |
operator+(const Matnnf< n > &v) const | Matnnf< 3 > |
operator+=(const Matnnf< n > &m) | Matnnf< 3 > |
operator-(void) const | Matnnf< 3 > |
operator-(const Matnnf< n > &v) const | Matnnf< 3 > |
operator-=(const Matnnf< n > &m) | Matnnf< 3 > |
operator/(float f) const | Matnnf< 3 > |
operator/=(float f) | Matnnf< 3 > |
operator=(const Matnnf< n > &m) | Matnnf< 3 > |
operator==(const Matnnf< n > &m) const | Matnnf< 3 > |
operator[](size_t i) | Matnnf< 3 > |
operator[](size_t i) const | Matnnf< 3 > |
operator~(void) const | Matnnf< 3 > |
set(const Vec3f &row0, const Vec3f &row1, const Vec3f &row2) | Mat33f | [inline]
Generated on Fri Aug 4 08:37:21 2006 for NVSGSDK by NVIDIA


Mat44f Class Reference

Two dimensional matrix of four times four floats. More...

#include <Mat44f.h>

Inheritance diagram for Mat44f:

[legend]
Collaboration diagram for Mat44f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Mat44f (void)
Default constructor.

NVSG_API | Mat44f (float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33)
Constructor using 16 floats.

NVSG_API | Mat44f (const Vec4f &row0, const Vec4f &row1, const Vec4f &row2, const Vec4f &row3)
Constructor using four row vectors.

NVSG_API | Mat44f (const Vec3f &trans, const Quatf &rot)
Constructor by Translation and Rotation.

NVSG_API | Mat44f (const Vec3f &trans, const Quatf &rot, const Vec3f &scale)
Constructor by Translation, Rotation, and Scaling.

NVSG_API | Mat44f (const Matnnf< 4 > &m)
Copy constructor.

NVSG_API void | set (const Vec4f &row0, const Vec4f &row1, const Vec4f &row2, const Vec4f &row3)
Set the matrix with four row vectors.

Related Functions

(Note that these are not member functions.)

void | decompose (const Mat44f &mat, Vec3f &translation, Quatf &orientation, Vec3f &scaling, Quatf &scaleOrientation)
NVSG_API const Mat44f | operator * (const Mat44f &m0, const Mat44f &m1)

Detailed Description

Two dimensional matrix of four times four floats.

A Mat44f can represent a full transformation (including rotation, scaling, and translation).

Constructor & Destructor Documentation

NVSG_API Mat44f ( void )

Default constructor.

For performance reasons no initialization is performed.

NVSG_API Mat44f | ( | float | a00,
 |  | float | a01,
 |  | float | a02,
 |  | float | a03,
 |  | float | a10,
 |  | float | a11,
 |  | float | a12,
 |  | float | a13,
 |  | float | a20,
 |  | float | a21,
 |  | float | a22,
 |  | float | a23,
 |  | float | a30,
 |  | float | a31,
 |  | float | a32,
 |  | float | a33
 | ) |

Constructor using 16 floats.

The 16 floats are used as the matrix elements. No normalization is performed.

NVSG_API Mat44f | ( | const Vec4f & | row0,
 |  | const Vec4f & | row1,
 |  | const Vec4f & | row2,
 |  | const Vec4f & | row3
 | ) |

Constructor using four row vectors.

The four vectors are used as the four rows of the matrix. No normalization is performed.

NVSG_API Mat44f | ( | const Vec3f & | trans,
 |  | const Quatf & | rot
 | ) |

Constructor by Translation and Rotation.

This constructs a matrix that represents the concatenation R * T

Parameters:
trans | translation
rot | quaternion for rotation

NVSG_API Mat44f | ( | const Vec3f & | trans,
 |  | const Quatf & | rot,
 |  | const Vec3f & | scale
 | ) |

Constructor by Translation, Rotation, and Scaling.

This constructs a matrix that represents the concatenation S * R * T

Parameters:
trans | translation
rot | quaternion for rotation
scale | scaling

NVSG_API Mat44f ( const Matnnf< 4 > & m )

Copy constructor.

Parameters:
m matrix to copy from

Member Function Documentation

NVSG_API void set | ( | const Vec4f & | row0,
 |  | const Vec4f & | row1,
 |  | const Vec4f & | row2,
 |  | const Vec4f & | row3
 | ) |

Set the matrix with four row vectors.

Friends And Related Function Documentation

void decompose | ( | const Mat44f & | mat,
 |  | Vec3f & | translation,
 |  | Quatf & | orientation,
 |  | Vec3f & | scaling,
 |  | Quatf & | scaleOrientation
 | ) | [related]

Decompose the non-singular Mat44f mat into translation, orientation, scaling, and scaleOrientation.
The matrix is assumed not to be a projection matrix.
The last column is considered to hold the translation.
The scaling, orientation, and scaleOrientation is calculated by decomposing the upper left 3x3 sub-matrix.

Parameters:
mat | matrix to decompose
translation | translation vector
orientation | rotational part
scaling | scaling factors
scaleOrientation | scaling rotation

NVSG_API const Mat44f operator * | ( | const Mat44f & | m0,
 |  | const Mat44f & | m1
 | ) | [related]

Matrix multiplication with a matrix (i.e. concatenation) operator.

Returns:
multiplied (concatenated) matrix

The documentation for this class was generated from the following file:
  • Mat44f.h
Generated on Fri Aug 4 08:37:21 2006 for NVSGSDK by NVIDIA


Member List

Mat44f Member List

This is the complete list of members for Mat44f, including all inherited members.
decompose(const Mat44f &mat, Vec3f &translation, Quatf &orientation, Vec3f &scaling, Quatf &scaleOrientation) | Mat44f | [related]
getPtr(void) const | Matnnf< 4 > |
invert(void) | Matnnf< 4 > |
Mat44f(void) | Mat44f |
Mat44f(float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33) | Mat44f |
Mat44f(const Vec4f &row0, const Vec4f &row1, const Vec4f &row2, const Vec4f &row3) | Mat44f |
Mat44f(const Vec3f &trans, const Quatf &rot) | Mat44f |
Mat44f(const Vec3f &trans, const Quatf &rot, const Vec3f &scale) | Mat44f |
Mat44f(const Matnnf< 4 > &m) | Mat44f |
Matnnf(void) | Matnnf< 4 > |
operator *(const Mat44f &m0, const Mat44f &m1) | Mat44f | [related]
nvmath::Matnnf< 4 >::operator *(float f) const | Matnnf< 4 > |
nvmath::Matnnf< 4 >::operator *(const Vecnf< n > &v) const | Matnnf< 4 > |
operator *=(float f) | Matnnf< 4 > |
operator *=(const Matnnf< n > &m) | Matnnf< 4 > |
operator!=(const Matnnf< n > &m) const | Matnnf< 4 > |
operator+(const Matnnf< n > &v) const | Matnnf< 4 > |
operator+=(const Matnnf< n > &m) | Matnnf< 4 > |
operator-(void) const | Matnnf< 4 > |
operator-(const Matnnf< n > &v) const | Matnnf< 4 > |
operator-=(const Matnnf< n > &m) | Matnnf< 4 > |
operator/(float f) const | Matnnf< 4 > |
operator/=(float f) | Matnnf< 4 > |
operator=(const Matnnf< n > &m) | Matnnf< 4 > |
operator==(const Matnnf< n > &m) const | Matnnf< 4 > |
operator[](size_t i) | Matnnf< 4 > |
operator[](size_t i) const | Matnnf< 4 > |
operator~(void) const | Matnnf< 4 > |
set(const Vec4f &row0, const Vec4f &row1, const Vec4f &row2, const Vec4f &row3) | Mat44f |
Generated on Fri Aug 4 08:37:21 2006 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

virtual NVSG_API const Material * | clone () const
Create a new Material by copying from this.

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.

Static Public Member Functions

NVSG_API const Material * | create ()
Create a Material.

NVSG_API const Material * | createFromBase (const StateAttribute &rhs)
Create a Material by copying from a StateAttribute.

Protected Member Functions

NVSG_API | Material ()
Protected constructor to prevent explicit creation.

NVSG_API | Material (const StateAttribute &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Material (const Material &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Material ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Material::create.

NVSG_API Material ( const StateAttribute & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StateAttribute to use as a base of the new Material
Remarks:
This constructor is never used explicitly, but only inside Material::createFromBase.
See also:
StateAttribute

NVSG_API Material ( const Material & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Material to copy from
Remarks:
This constructor is never used explicitly, but only inside Material::create.

virtual NVSG_API ~Material ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Material is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Material* create ( ) [static]

Create a Material.

Returns:
A pointer to a constant Material.
Remarks:
A default Material is created with the above described defaults for both front and back faces.

NVSG_API const Material* createFromBase ( const StateAttribute & rhs ) [static]

Create a Material by copying from a StateAttribute.

Parameters:
rhs A reference to the constant StateAttribute to copy from
Returns:
A pointer to a constant Material.
Remarks:
All the data from the StateAttribute rhs is used as the base information for the newly created Material. Material specific data is initialized as if Material::create was called.
See also:
StateAttribute

virtual NVSG_API const Material* clone ( ) const [virtual]

Create a new Material by copying from this.

Returns:
A pointer to a constant Material.
Remarks:
The newly created Material is an exact copy of this.

Implements StateAttribute.

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 Fri Aug 4 08:38:14 2006 for NVSGSDK by NVIDIA


Member List

Material Member List

This is the complete list of members for Material, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | Material | [virtual]
create() | Material | [static]
createFromBase(const StateAttribute &rhs) | Material | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAmbientColor(MaterialFace mf=MF_FRONT) const | Material | [inline]
getDataID() const | Material | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
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 |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getOpacity(MaterialFace mf=MF_FRONT) const | Material | [inline]
getParent(size_t index) const | StateAttribute | [inline]
getSpecularColor(MaterialFace mf=MF_FRONT) const | Material | [inline]
getSpecularExponent(MaterialFace mf=MF_FRONT) const | Material | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Material | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Material | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Material() | Material | [protected]
Material(const StateAttribute &rhs) | Material | [explicit, protected]
Material(const Material &rhs) | Material | [protected]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Material &rhs) | Material |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAmbientColor(const nvmath::Vec3f &ac, MaterialFace mf=MF_FRONT_AND_BACK) | Material |
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 |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Material() | Material | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:38:14 2006 for NVSGSDK by NVIDIA


TemplateMatnnf class Reference

Matnnf Class Template Reference

Template for two dimensional matrices of floats. More...

#include <Matnnf.h>

Inheritance diagram for Matnnf:

[legend]
List of all members.

Public Member Functions

Matnnf (void)
Default constructor.

bool | invert (void)
Calculate the inverse of a matrix.

Vecnf< n > & | operator[] (size_t i)
Non-constant subscript operator.

const Vecnf< n > & | operator[] (size_t i) const
Constant subscript operator.

const Matnnf< n > | operator~ (void) const
Transpose operator.

const Matnnf< n > | operator- (void) const
Negation operator.

const Matnnf< n > | operator * (float f) const
Matrix multiplication with a scalar operator.

const Vecnf< n > | operator * (const Vecnf< n > &v) const
Matrix multiplication with a vector operator.

const Matnnf< n > | operator/ (float f) const
Matrix division by a scalar operator.

const Matnnf< n > | operator+ (const Matnnf< n > &v) const
Matrix addition operator.

const Matnnf< n > | operator- (const Matnnf< n > &v) const
Matrix subtraction operator.

bool | operator== (const Matnnf< n > &m) const
Equality operator.

bool | operator!= (const Matnnf< n > &m) const
Inequality operator.

Matnnf< n > & | operator= (const Matnnf< n > &m)
Assignment operator.

Matnnf< n > & | operator *= (float f)
Matrix multiplication with a scalar and assignment operator.

Matnnf< n > & | operator *= (const Matnnf< n > &m)
Matrix multiplication with a matrix (i.e. concatenation) and assignment operator.

Matnnf< n > & | operator/= (float f)
Matrix division by a scalar and assignment operator.

Matnnf< n > & | operator+= (const Matnnf< n > &m)
Matrix addition and assignment operator.

Matnnf< n > & | operator-= (const Matnnf< n > &m)
Matrix subtraction and assignment operator.

const float * | getPtr (void) const
Get a constant pointer to the n times n floats of the matrix.

Related Functions

(Note that these are not member functions.)

bool | isIdentity (const Matnnf< n > &m, float epsilon=FLT_EPSILON)
bool | isNormalized (const Matnnf< n > &mat, float epsilon=FLT_EPSILON)
bool | isNull (const Matnnf< n > &mat, float epsilon=FLT_EPSILON)
bool | isOrthogonal (const Matnnf< n > &mat, float epsilon=FLT_EPSILON)
const Matnnf< n > | operator * (float f, const Matnnf< n > &m)
const Matnnf< n > | operator * (const Matnnf< n > &m0, const Matnnf< n > &m1)
void | setIdentity (Matnnf< n > &m)

Detailed Description

template<unsigned char n>
class nvmath::Matnnf< n >

Template for two dimensional matrices of floats.

A Matnnf is organized as n Vecnf.

Constructor & Destructor Documentation

Matnnf ( void )

Default constructor.

For performance reasons no initialization is performed.

Member Function Documentation

bool invert ( void )

Calculate the inverse of a matrix.

Note:
If the matrix is not invertible, the resulting matrix is undefined.
Returns:
true, if the matrix was invertible, otherwise false

Vecnf< n > & operator[] ( size_t i )

Non-constant subscript operator.

Returns:
reference to i th row of the matrix
Parameters:
i index to row to use (i=0,..,n-1)

const Vecnf< n > & operator[] ( size_t i ) const

Constant subscript operator.

Returns:
constant reference to i th row of the matrix
Parameters:
i index to row to use (i=0,..,n-1)

const Matnnf< n > operator~ ( void ) const

Transpose operator.

Returns:
transposed matrix

const Matnnf< n > operator- ( void ) const

Negation operator.

Returns:
negated matrix

const Matnnf< n > operator * ( float f ) const

Matrix multiplication with a scalar operator.

Returns:
multiplied matrix
Parameters:
f scalar to multiply with

const Vecnf< n > operator * ( const Vecnf< n > & v ) const

Matrix multiplication with a vector operator.

Returns:
matrix times v
Parameters:
v vector to multiply with

const Matnnf< n > operator/ ( float f ) const

Matrix division by a scalar operator.

Returns:
divided matrix
Parameters:
f scalar to divide through

const Matnnf< n > operator+ ( const Matnnf< n > & v ) const

Matrix addition operator.

Returns:
sum of the two matrices
Parameters:
m matrix to add

const Matnnf< n > operator- ( const Matnnf< n > & v ) const

Matrix subtraction operator.

Returns:
difference of the two matrices
Parameters:
m matrix to add

bool operator== ( const Matnnf< n > & m ) const

Equality operator.

Returns:
true if the matrix is equal to m, otherwise false
Parameters:
m matrix to compare with

bool operator!= ( const Matnnf< n > & m ) const

Inequality operator.

Returns:
true if the matrix is not equal to m, otherwise false
Parameters:
m matrix to compare with

Matnnf< n > & operator= ( const Matnnf< n > & m )

Assignment operator.

Returns:
reference to the assigned matrix
Parameters:
m matrix to copy

Matnnf< n > & operator *= ( float f )

Matrix multiplication with a scalar and assignment operator.

Returns:
reference to the assigned matrix after multiplication
Parameters:
f scalar to multiply with

Matnnf< n > & operator *= ( const Matnnf< n > & m )

Matrix multiplication with a matrix (i.e. concatenation) and assignment operator.

Returns:
reference to the assigned matrix after multiplication (concatenation)
Parameters:
m matrix to multiply

Matnnf< n > & operator/= ( float f )

Matrix division by a scalar and assignment operator.

Returns:
reference to the assigned matrix after division
Parameters:
f scalar to divide through

Matnnf< n > & operator+= ( const Matnnf< n > & m )

Matrix addition and assignment operator.

Returns:
reference to the assigned matrix after addition
Parameters:
m matrix to add

Matnnf< n > & operator-= ( const Matnnf< n > & m )

Matrix subtraction and assignment operator.

Returns:
reference to the assigned matrix after addition
Parameters:
m matrix to subtract

const float * getPtr ( void ) const

Get a constant pointer to the n times n floats of the matrix.

Returns:
constant pointer to matrix elements

Friends And Related Function Documentation

bool isIdentity | ( | const Matnnf< n > & | m,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Matnnf is the identity.
A Matnnf is considered to be the identity, if each of the diagonal elements differ less than epsilon from one, and each of the other matrix elements differ less than epsilon from zero.

Returns:
true if the matrix is the identity, otherwise false
Parameters:
m | matrix to test
epsilon | optional epsilon

bool isNormalized | ( | const Matnnf< n > & | mat,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Matnnf is normalized.
A Matnnf is normalized when all rows and all columns are normalized.

Returns:
true if the matrix is normalized, otherwise false
Parameters:
mat | matrix to test
epsilon | optional epsilon

bool isNull | ( | const Matnnf< n > & | mat,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Matnnf is a null matrix.
A Matnnf is considered to be a null matrix when each of it's rows is a null vector.

Returns:
true if the matrix is a null matrix, otherwise false
Parameters:
mat | matrix to test
epsilon | optional epsilon

bool isOrthogonal | ( | const Matnnf< n > & | mat,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Matnnf is orthogonal.
A Matnnf is orthogonal when every row is orthogonal to each other row and every column is orthogonal to each other column.

Returns:
true if the matrix is orthogonal, otherwise false
Parameters:
mat | matrix to test
epsilon | optional epsilon

const Matnnf< n > operator * | ( | float | f,
 |  | const Matnnf< n > & | m
 | ) | [related]

Matrix multiplication with a scalar operator.

Returns:
multiplied matrix

const Matnnf< n > operator * | ( | const Matnnf< n > & | m0,
 |  | const Matnnf< n > & | m1
 | ) | [related]

Matrix multiplication with a matrix (i.e. concatenation) operator.

Returns:
multiplied (concatenated) matrix

void setIdentity ( Matnnf< n > & m ) [related]

Set Matrix to identity.

The documentation for this class was generated from the following file:
  • Matnnf.h
Generated on Fri Aug 4 08:37:22 2006 for NVSGSDK by NVIDIA


Member List

Matnnf Member List

This is the complete list of members for Matnnf, including all inherited members.
getPtr(void) const | Matnnf |
invert(void) | Matnnf |
isIdentity(const Matnnf< n > &m, float epsilon=FLT_EPSILON) | Matnnf | [related]
isNormalized(const Matnnf< n > &mat, float epsilon=FLT_EPSILON) | Matnnf | [related]
isNull(const Matnnf< n > &mat, float epsilon=FLT_EPSILON) | Matnnf | [related]
isOrthogonal(const Matnnf< n > &mat, float epsilon=FLT_EPSILON) | Matnnf | [related]
Matnnf(void) | Matnnf |
operator *(float f) const | Matnnf |
operator *(const Vecnf< n > &v) const | Matnnf |
operator *(float f, const Matnnf< n > &m) | Matnnf | [related]
operator *(const Matnnf< n > &m0, const Matnnf< n > &m1) | Matnnf | [related]
operator *=(float f) | Matnnf |
operator *=(const Matnnf< n > &m) | Matnnf |
operator!=(const Matnnf< n > &m) const | Matnnf |
operator+(const Matnnf< n > &v) const | Matnnf |
operator+=(const Matnnf< n > &m) | Matnnf |
operator-(void) const | Matnnf |
operator-(const Matnnf< n > &v) const | Matnnf |
operator-=(const Matnnf< n > &m) | Matnnf |
operator/(float f) const | Matnnf |
operator/=(float f) | Matnnf |
operator=(const Matnnf< n > &m) | Matnnf |
operator==(const Matnnf< n > &m) const | Matnnf |
operator[](size_t i) | Matnnf |
operator[](size_t i) const | Matnnf |
operator~(void) const | Matnnf |
setIdentity(Matnnf< n > &m) | Matnnf | [related]
Generated on Fri Aug 4 08:37:22 2006 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 Fri Aug 4 08:40:10 2006 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 Fri Aug 4 08:40:10 2006 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

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 size_t | 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, size_t numMeshes)
Set the meshes of this MeshedPrimitiveSet.

NVSG_API void | setMeshes (size_t pos, const IndexMesh *meshes, size_t numMeshes)
Set a subset of meshes of this MeshedPrimitiveSet.

virtual NVSG_API const MeshedPrimitiveSet * | clone () const=0
Interface for creating a new MeshedPrimitiveSet by copying from this.

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 ()
Protected constructor to prevent explicit creation.

NVSG_API | MeshedPrimitiveSet (const MeshedPrimitiveSet &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~MeshedPrimitiveSet ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
The newly created MeshedPrimitiveSet has no meshes.
Note:
A MeshedPrimitiveSet will not be instantiated directly, but through instantiating a derived object like QuadMeshes for example.

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.

virtual NVSG_API ~MeshedPrimitiveSet ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the MeshedPrimitiveSet is decremented to zero.
See also:
addRef, removeRef

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

size_t 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,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const IndexMesh * | meshes,
 |  | size_t | 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
Parameters:
pos | Start position inside the range of pre-existing meshes
meshes | meshes to set
numMeshes | number of meshes

virtual NVSG_API const MeshedPrimitiveSet* clone ( ) const [pure virtual]

Interface for creating a new MeshedPrimitiveSet by copying from this.

Returns:
A pointer to a constant MeshedPrimitiveSet.
Remarks:
The newly created MeshedPrimitiveSet is an exact copy of this.

Implements PrimitiveSet.

Implemented in QuadMeshes.

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::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.

Reimplemented from PrimitiveSet.

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 Fri Aug 4 08:38:15 2006 for NVSGSDK by NVIDIA


Member List

MeshedPrimitiveSet Member List

This is the complete list of members for MeshedPrimitiveSet, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | MeshedPrimitiveSet | [protected, virtual]
clone() const=0 | MeshedPrimitiveSet | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | MeshedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getMeshes() const | MeshedPrimitiveSet | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfMeshes() const | MeshedPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasMeshes() const | MeshedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | MeshedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | MeshedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
MeshedPrimitiveSet() | MeshedPrimitiveSet | [protected]
MeshedPrimitiveSet(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setMeshes(const IndexMesh *meshes, size_t numMeshes) | MeshedPrimitiveSet |
setMeshes(size_t pos, const IndexMesh *meshes, size_t numMeshes) | MeshedPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MeshedPrimitiveSet() | MeshedPrimitiveSet | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:15 2006 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 Fri Aug 4 08:36:31 2006 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 Fri Aug 4 08:36:31 2006 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

size_t | 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

size_t missingCount

The number of objects with missing information.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:05 2006 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 Fri Aug 4 08:39:05 2006 for NVSGSDK by NVIDIA


ModelViewTraverser Class Reference

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

#include <ModelViewTraverser.h>

Inheritance diagram for ModelViewTraverser:

[legend]
Collaboration diagram for ModelViewTraverser:

[legend]
List of all members.

Public Member Functions

virtual NVSG_API void | setViewState (const nvsg::ViewState *viewState)
Set a valid ViewState.

Protected Member Functions

NVSG_API | ModelViewTraverser (bool readOnly=true)
Protected constructor to prevent instantiation of a ModelViewTraverser.

virtual NVSG_API | ~ModelViewTraverser ()
Protected destructor to prevent instantiation of a ModelViewTraverser.

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 *p)
Routine to handle a LOD (Level Of Detail) node while traversing the scene graph.

virtual NVSG_API void | handleParallelCamera (const nvsg::ParallelCamera *p, const nvsg::Node *root)
Provide special treatment of a ParallelCamera object.

virtual NVSG_API void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p, const nvsg::Node *root)
Provide special treatment of a PerspectiveCamera object.

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 bool | preTraverseRoot (const nvsg::Camera *p, const nvsg::Node *root)
Handles actions to take just before the scene is traversed.

Protected Attributes

nvmath::Vec3f | m_cameraPosition
nvmath::Vec3f | m_cameraUpVector
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 ModelViewTraverser ( bool readOnly = true ) [protected]

Protected constructor to prevent instantiation of a ModelViewTraverser.

Note:
A ModelViewTraverser 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 ~ModelViewTraverser ( ) [protected, virtual]

Protected destructor to prevent instantiation of a ModelViewTraverser.

Member Function Documentation

virtual NVSG_API void setViewState ( const nvsg::ViewState * viewState ) [virtual]

Set a valid ViewState.

Set the ViewState to work with.

Note:
This traverser needs a valid ViewState. Call setViewState prior to apply().
Parameters:
viewState pointer to a valid ViewState.

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 Traverser.

Reimplemented in AppTraverser, and 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 Traverser.

Reimplemented in CullTraverser, RayIntersectTraverser, and RenderTraverser.

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.

This routine gets called for each LOD object that will be visited while traversing the scene graph. The currently visited LOD object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

Reimplemented in CullTraverser, and RayIntersectTraverser.

virtual NVSG_API void handleParallelCamera | ( | const nvsg::ParallelCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Provide special treatment of a ParallelCamera object.

The function initializes the model view transformation stack and calls the base class handler function.

Parameters:
p | ParallelCamera to handle
root | root node of scene to traverse

Reimplemented from Traverser.

Reimplemented in RenderTraverser.

virtual NVSG_API void handlePerspectiveCamera | ( | const nvsg::PerspectiveCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Provide special treatment of a PerspectiveCamera object.

The function initializes the model view transformation stack and calls the base class handler function.

Parameters:
p | PerspectiveCamera to handle
root | root node of scene to traverse

Reimplemented from Traverser.

Reimplemented in RenderTraverser.

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 Traverser.

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 bool preTraverseRoot | ( | const nvsg::Camera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Handles actions to take just before the scene is traversed.

This initializes the camera related part of the transform stack (after traversal of the headlights).

Parameters:
p | camera that is used here
root | root node to traverse from

Reimplemented from Traverser.

Reimplemented in FrustumCullTraverser.

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:
  • ModelViewTraverser.h
Generated on Fri Aug 4 08:39:25 2006 for NVSGSDK by NVIDIA


Member List

ModelViewTraverser Member List

This is the complete list of members for ModelViewTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | Traverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | ModelViewTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | ModelViewTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | ModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | ModelViewTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | ModelViewTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | ModelViewTraverser | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setViewState(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:25 2006 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 Fri Aug 4 08:39:58 2006 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 Fri Aug 4 08:39:58 2006 for NVSGSDK by NVIDIA


NBFAnimatedIndependents Struct Reference

The NBFAnimatedIndependents structure represents animated independent primitives. More...

#include <NBF.h>

Inheritance diagram for NBFAnimatedIndependents:

[legend]
Collaboration diagram for NBFAnimatedIndependents:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFAnimatedIndependents is a multiple of 8, regardless of packing.

Public Attributes

uint_t animation

Detailed Description

The NBFAnimatedIndependents structure represents animated independent primitives.

A NBFAnimatedIndependents is an abstract topology class derived from NBFIndependentPrimitiveSet. The object code for a NBFAnimatedIndependents is NBF_ANIMATED_QUADS and NBF_ANIMATED_TRIANGLES.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFAnimatedIndependents is a multiple of 8, regardless of packing.

Reimplemented from NBFPrimitiveSet.

Member Data Documentation

uint_t animation

Specifies the file offset to the NBFVNVectorAnimation object < to be applied to the independent faces.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:32 2006 for NVSGSDK by NVIDIA


Member List

NBFAnimatedIndependents Member List

This is the complete list of members for NBFAnimatedIndependents, including all inherited members.
animation | NBFAnimatedIndependents
indices | NBFIndependentPrimitiveSet
isShared | NBFObject
numIndices | NBFIndependentPrimitiveSet
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFAnimatedIndependents
NBFDrawable::PADDING(3) | NBFObject
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Fri Aug 4 08:36:32 2006 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 Fri Aug 4 08:36:32 2006 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 (defined in NBFNode) | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
numChildren | NBFGroup
numClipPlanes | NBFGroup
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFAnimatedTransform
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
trafo (defined in NBFTransform) | NBFTransform
userHints | NBFNode
Generated on Fri Aug 4 08:36:32 2006 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
ubyte_t | screenAligned

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.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:33 2006 for NVSGSDK by NVIDIA


Member List

NBFBillboard Member List

This is the complete list of members for NBFBillboard, including all inherited members.
annotation (defined in NBFNode) | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
numChildren | NBFGroup
numClipPlanes | NBFGroup
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFBillboard
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(4) | NBFObject
rotationAxis (defined in NBFBillboard) | NBFBillboard
screenAligned (defined in NBFBillboard) | NBFBillboard
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:33 2006 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 Fri Aug 4 08:36:33 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFBlendAttribute
NBFStateAttribute::PADDING(3) | NBFObject
NBFStateAttribute::PADDING(4) | NBFObject
sourceFunction | NBFBlendAttribute
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:33 2006 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 NBFTrafoAnimation 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 NBFTrafoAnimation is a multiple of 8, regardless of packing.

Reimplemented from NBFObject.

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 Fri Aug 4 08:36:34 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCamera
PADDING(4) | NBFCamera
position | NBFCamera
sourceObject | NBFObject
upVector | NBFCamera
windowOffset | NBFCamera
windowSize | NBFCamera
Generated on Fri Aug 4 08:36:34 2006 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
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
uint_t numSamplers
Specifies the number of sampler parameters stored.

uint_t | samplers
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.

Reimplemented from NBFObject.

Member Data Documentation

str_t source

Holds either the filename of an effect file or a source code string.

!< Specifies whether the effect's source is a file. If this is false, the source member below is interpreted as a code string.

uint_t numTweaks

Specifies the number of tweakable effect parameters stored.

uint_t numSamplers

Specifies the number of sampler parameters stored.

!< Specifies the file offset to the tweakable effect paramters. Tweakables in the NBF format are stored as tweak_t objects.

str_t currTech

Specifies the name of the current technique used with rendering.

!< Specifies the file offset t the sampler parameters. Samplers parameters a stored as sampler_t objects.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:34 2006 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 (defined in NBFCgFx) | NBFCgFx
isShared | NBFObject
numSamplers | NBFCgFx
numTweaks | NBFCgFx
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCgFx
PADDING(4) | NBFCgFx
samplers (defined in NBFCgFx) | NBFCgFx
source | NBFCgFx
sourceObject | NBFObject
tweaks (defined in NBFCgFx) | NBFCgFx
Generated on Fri Aug 4 08:36:34 2006 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 Fri Aug 4 08:36:35 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(5) | NBFDepthAttribute
NBFStateAttribute::PADDING(3) | NBFObject
NBFStateAttribute::PADDING(4) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:35 2006 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)
Padding bits to ensure the size of NBFObject is a multiple of 8, regardless of packing.

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 Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFObject is a multiple of 8, regardless of packing.

Reimplemented from NBFObject.

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 Fri Aug 4 08:36:35 2006 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
annotation (defined in NBFNode) | NBFNode
castShadow | NBFLightSource
diffuseColor | NBFLightSource
direction | NBFDirectedLight
intensity | NBFLightSource
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFDirectedLight
NBFLightSource::PADDING(3) | NBFLightSource
NBFNode::PADDING(6) | NBFNode
sourceObject | NBFObject
specularColor | NBFLightSource
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:35 2006 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 Fri Aug 4 08:36:36 2006 for NVSGSDK by NVIDIA


Member List

NBFDrawable Member List

This is the complete list of members for NBFDrawable, including all inherited members.
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:36 2006 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 Fri Aug 4 08:36:36 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(2) | NBFFaceAttribute
PADDING(1) | NBFFaceAttribute
NBFStateAttribute::PADDING(3) | NBFObject
NBFStateAttribute::PADDING(4) | NBFObject
polygonOffsetEnabled | NBFFaceAttribute
polygonOffsetFactor | NBFFaceAttribute
polygonOffsetUnits | NBFFaceAttribute
sourceObject | NBFObject
twoSidedLighting | NBFFaceAttribute
Generated on Fri Aug 4 08:36:37 2006 for NVSGSDK by NVIDIA


NBFFramedAnimation Struct Reference

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

#include <NBF.h>

Inheritance diagram for NBFFramedAnimation:

[legend]
List of all members.

Public Attributes

uint_t numFrames

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 NBFTrafoAnimation or NBFVNVectorAnimation.
Concrete object codes valid for a NBFFramedAnimation are NBF_FRAMED_TRAFO_ANIMATION and NBF_FRAMED_VNVECTOR_ANIMATION. Further concrete object codes valid for NBFFramedAnimation objects are subject to future extensions of the NBF format.

Member Data Documentation

uint_t numFrames

Specifies the number of animation frames.
< In conjunction with a NBFTrafoAnimation, this corresponds to the number of < trafo_t objects stored with a NBFTrafoAnimation.
< In conjunction with a NBFVNVectorAnimation, this corresponds to the number of < vertex/normal sets stored with a NBFVNVectorAnimation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:37 2006 for NVSGSDK by NVIDIA


Member List

NBFFramedAnimation Member List

This is the complete list of members for NBFFramedAnimation, including all inherited members.
numFrames NBFFramedAnimation
Generated on Fri Aug 4 08:36:37 2006 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.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFFramedTrafoAnimation is a multiple of 8, regardless of packing.

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.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFFramedTrafoAnimation is a multiple of 8, regardless of packing.

Reimplemented from NBFTrafoAnimation.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:37 2006 for NVSGSDK by NVIDIA


Member List

NBFFramedTrafoAnimation Member List

This is the complete list of members for NBFFramedTrafoAnimation, including all inherited members.
isShared | NBFObject
numFrames | NBFFramedAnimation
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFFramedTrafoAnimation
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
trafos | NBFTrafoAnimation
Generated on Fri Aug 4 08:36:37 2006 for NVSGSDK by NVIDIA


NBFFramedVNVectorAnimation Struct Reference

The NBFFramedVNVectorAnimation structure represents a framed animation that will be applied to VNVector objects. More...

#include <NBF.h>

Inheritance diagram for NBFFramedVNVectorAnimation:

[legend]
Collaboration diagram for NBFFramedVNVectorAnimation:

[legend]
List of all members.

Public Member Functions

PADDING (4)
Padding bits to ensure the size of NBFFramedVNVectorAnimation is a multiple of 8, regardless of packing.

Detailed Description

The NBFFramedVNVectorAnimation structure represents a framed animation that will be applied to VNVector objects.

A NBFFramedVNVectorAnimation is a concrete animation type. It publicly inherits from NBFVNVectorAnimation and NBFFramedAnimation. The object code for a NBFFramedVNVectorAnimation is NBF_FRAMED_VNVECTOR_ANIMATION.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFFramedVNVectorAnimation is a multiple of 8, regardless of packing.

Reimplemented from NBFObject.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:38 2006 for NVSGSDK by NVIDIA


Member List

NBFFramedVNVectorAnimation Member List

This is the complete list of members for NBFFramedVNVectorAnimation, including all inherited members.
isShared | NBFObject
normalSets | NBFVNVectorAnimation
numFrames | NBFFramedAnimation
numNormals | NBFVNVectorAnimation
numVertices | NBFVNVectorAnimation
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFFramedVNVectorAnimation
NBFVNVectorAnimation::PADDING(3) | NBFObject
sourceObject | NBFObject
vertexSets | NBFVNVectorAnimation
Generated on Fri Aug 4 08:36:38 2006 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
uint_t | geometrySets

Detailed Description

The NBFGeoNode structure represents a geometry node.

The object code for a NBFGeoNode is NBF_GEO_NODE.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:38 2006 for NVSGSDK by NVIDIA


Member List

NBFGeoNode Member List

This is the complete list of members for NBFGeoNode, including all inherited members.
annotation (defined in NBFNode) | NBFNode
geometrySets (defined in NBFGeoNode) | NBFGeoNode
isShared | NBFObject
numGeometrySets (defined in NBFGeoNode) | NBFGeoNode
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
NBFObject::PADDING(4) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:38 2006 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.

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.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:39 2006 for NVSGSDK by NVIDIA


Member List

NBFGroup Member List

This is the complete list of members for NBFGroup, including all inherited members.
annotation (defined in NBFNode) | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
numChildren | NBFGroup
numClipPlanes | NBFGroup
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
NBFObject::PADDING(4) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:39 2006 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 Fri Aug 4 08:36:39 2006 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 Fri Aug 4 08:36:39 2006 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 Fri Aug 4 08:36:40 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFPrimitiveSet
NBFDrawable::PADDING(3) | NBFObject
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Fri Aug 4 08:36:40 2006 for NVSGSDK by NVIDIA


NBFInterpolatedAnimation Struct Reference

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

#include <NBF.h>

Inheritance 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 NBFVNVectorAnimation.
Concrete object codes valid for a NBFInterpolatedAnimation are NBF_LINEAR_INTERPOLATED_TRAFO_ANIMATION and NBF_LINEAR_INTERPOLATED_VNVECTOR_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 Fri Aug 4 08:36:40 2006 for NVSGSDK by NVIDIA


Member List

NBFInterpolatedAnimation Member List

This is the complete list of members for NBFInterpolatedAnimation, including all inherited members.
keys | NBFInterpolatedAnimation
numKeys | NBFInterpolatedAnimation
Generated on Fri Aug 4 08:36:40 2006 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 Fri Aug 4 08:36:40 2006 for NVSGSDK by NVIDIA


Member List

NBFInterpolatedTrafoAnimation Member List

This is the complete list of members for NBFInterpolatedTrafoAnimation, including all inherited members.
isShared | NBFObject
keys | NBFInterpolatedAnimation
numKeys | NBFInterpolatedAnimation
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFTrafoAnimation
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
trafos | NBFTrafoAnimation
Generated on Fri Aug 4 08:36:40 2006 for NVSGSDK by NVIDIA


NBFInterpolatedVNVectorAnimation Struct Reference

The NBFInterpolatedVNVectorAnimation structure represents a interpolated animation that will be applied to VNVector objects. More...

#include <NBF.h>

Inheritance diagram for NBFInterpolatedVNVectorAnimation:

[legend]
Collaboration diagram for NBFInterpolatedVNVectorAnimation:

[legend]
List of all members.

Detailed Description

The NBFInterpolatedVNVectorAnimation structure represents a interpolated animation that will be applied to VNVector objects.

A NBFInterpolatedVNVectorAnimation is a concrete animation type. It publicly inherits from NBFVNVectorAnimation and NBFInterpolatedAnimation.
The object code valid for a NBFInterpolatedVNVectorAnimation is NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION. Further object codes valid for NBFInterpolatedVNVectorAnimation 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 Fri Aug 4 08:36:41 2006 for NVSGSDK by NVIDIA


Member List

NBFInterpolatedVNVectorAnimation Member List

This is the complete list of members for NBFInterpolatedVNVectorAnimation, including all inherited members.
isShared | NBFObject
keys | NBFInterpolatedAnimation
normalSets | NBFVNVectorAnimation
numKeys | NBFInterpolatedAnimation
numNormals | NBFVNVectorAnimation
numVertices | NBFVNVectorAnimation
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
vertexSets | NBFVNVectorAnimation
Generated on Fri Aug 4 08:36:41 2006 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 (3)
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.

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 ( 3 )

Padding bits to ensure the offset of the next struct member is on a 4-byte boundary.

Reimplemented from NBFObject.

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.

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 Fri Aug 4 08:36:42 2006 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
annotation (defined in NBFNode) | NBFNode
castShadow | NBFLightSource
diffuseColor | NBFLightSource
intensity | NBFLightSource
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFLightSource
NBFNode::PADDING(6) | NBFNode
NBFObject::PADDING(4) | NBFObject
sourceObject | NBFObject
specularColor | NBFLightSource
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:42 2006 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 Fri Aug 4 08:36:42 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFLineAttribute
NBFStateAttribute::PADDING(4) | NBFObject
sourceObject | NBFObject
stippleFactor | NBFLineAttribute
stipplePattern | NBFLineAttribute
width | NBFLineAttribute
Generated on Fri Aug 4 08:36:42 2006 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.

const nvsg::Scene * | load (const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&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 const nvsg::Object * | 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, 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 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.

const nvsg::Scene* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | const nvsg::ViewState *& | viewState
 | ) |

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.

virtual const nvsg::Object* 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 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,
 |  | size_t | numBytes
 | ) | [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 ) [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 Fri Aug 4 08:36:43 2006 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]
deleteThis(void) | NBFLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&viewState) | NBFLoader |
nvsg::SceneLoader::load(const std::string &filename, const std::vector< std::string > &searchPaths, const ViewState *&viewState)=0 | SceneLoader | [pure virtual]
loadCustomObject(uint_t objectCode, uint_t offset) | NBFLoader | [protected, virtual]
mapOffset(uint_t offset, size_t numBytes) | NBFLoader | [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 | [protected]
~NBFLoader(void) | NBFLoader | [protected, virtual]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~SceneLoader() | SceneLoader | [protected, virtual]
Generated on Fri Aug 4 08:36:43 2006 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.

Reimplemented from NBFObject.

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 Fri Aug 4 08:36:44 2006 for NVSGSDK by NVIDIA


Member List

NBFLOD Member List

This is the complete list of members for NBFLOD, including all inherited members.
annotation (defined in NBFNode) | NBFNode
center | NBFLOD
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
numChildren | NBFGroup
numClipPlanes | NBFGroup
numRanges | NBFLOD
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 Fri Aug 4 08:36:44 2006 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 Fri Aug 4 08:36:45 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:45 2006 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 Fri Aug 4 08:36:45 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFPrimitiveSet
NBFDrawable::PADDING(3) | NBFObject
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Fri Aug 4 08:36:45 2006 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
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, and NBF_SPOT_LIGHT. 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

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 Fri Aug 4 08:36:46 2006 for NVSGSDK by NVIDIA


Member List

NBFNode Member List

This is the complete list of members for NBFNode, including all inherited members.
annotation (defined in NBFNode) | NBFNode
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
NBFObject::PADDING(4) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:46 2006 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.

PADDING (4)
Padding bits to ensure the size of NBFObject is a multiple of 8, 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
str_t objectName
Specifies an optional name for the actual 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, NBFLightSource, NBFCgFx, NBFLineAttribute, and NBFPointAttribute.

PADDING ( 4 )

Padding bits to ensure the size of NBFObject is a multiple of 8, regardless of packing.

Reimplemented in NBFTrafoAnimation, NBFFramedTrafoAnimation, NBFFramedVNVectorAnimation, NBFCamera, NBFPrimitiveSet, NBFAnimatedIndependents, NBFLOD, NBFTransform, NBFAnimatedTransform, NBFDirectedLight, NBFSpotLight, NBFStateSet, and NBFCgFx.

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.

str_t objectName

Specifies an optional name for the actual object.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:46 2006 for NVSGSDK by NVIDIA


Member List

NBFObject Member List

This is the complete list of members for NBFObject, including all inherited members.
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:46 2006 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 Fri Aug 4 08:36:47 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCamera
PADDING(4) | NBFCamera
position | NBFCamera
sourceObject | NBFObject
upVector | NBFCamera
windowOffset | NBFCamera
windowSize | NBFCamera
Generated on Fri Aug 4 08:36:47 2006 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 Fri Aug 4 08:36:47 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFCamera
PADDING(4) | NBFCamera
position | NBFCamera
sourceObject | NBFObject
upVector | NBFCamera
windowOffset | NBFCamera
windowSize | NBFCamera
Generated on Fri Aug 4 08:36:47 2006 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 Fri Aug 4 08:36:48 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFPointAttribute
NBFStateAttribute::PADDING(4) | NBFObject
size | NBFPointAttribute
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:48 2006 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 Fri Aug 4 08:36:48 2006 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
annotation (defined in NBFNode) | NBFNode
attenuation | NBFPointLight
castShadow | NBFLightSource
diffuseColor | NBFLightSource
intensity | NBFLightSource
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFLightSource
NBFNode::PADDING(6) | NBFNode
NBFObject::PADDING(4) | NBFObject
position | NBFPointLight
sourceObject | NBFObject
specularColor | NBFLightSource
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:48 2006 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 Member Functions

PADDING (4)
Padding bits to ensure the size of NBFAnimatedIndependents is a multiple of 8, regardless of packing.

Public Attributes

uint_t vertexAttributeSet
Specifies the file offset to the vertex attribute set.

Detailed Description

The NBFPrimitiveSet structure represents a geometry with an NBFVertexAttributeSet.

A NBFPrimitiveSet holds the offset to an NBFVertexAttributeSet.

Member Function Documentation

PADDING ( 4 )

Padding bits to ensure the size of NBFAnimatedIndependents is a multiple of 8, regardless of packing.

Reimplemented from NBFObject.

Reimplemented in NBFAnimatedIndependents.

Member Data Documentation

uint_t vertexAttributeSet

Specifies the file offset to the vertex attribute set.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:49 2006 for NVSGSDK by NVIDIA


Member List

NBFPrimitiveSet Member List

This is the complete list of members for NBFPrimitiveSet, including all inherited members.
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFPrimitiveSet
NBFDrawable::PADDING(3) | NBFObject
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Fri Aug 4 08:36:49 2006 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 (const nvsg::Scene &scene, const nvsg::ViewState *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 | ( | const nvsg::Scene & | scene,
 |  | const nvsg::ViewState * | viewState,
 |  | const std::string & | filename
 | ) |

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

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 Fri Aug 4 08:36:50 2006 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]
deleteThis(void) | NBFSaver | [inline, virtual]
m_traverser | NBFSaver | [protected]
NBFSaver() | NBFSaver |
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(const nvsg::Scene &scene, const nvsg::ViewState *viewState, const std::string &filename) | NBFSaver |
nvsg::SceneSaver::save(const Scene &scene, const ViewState *viewState, const std::string &filename)=0 | SceneSaver | [pure 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 Fri Aug 4 08:36:50 2006 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 Types

enum | { VIEWSIZE = 0x01000000 }

Public Member Functions

NBFSaveTraverser ()
Default constructor.

void | preCalculateFileSize (const nvsg::Scene *scene)
pre-calculate what the file size would be

bool | mapViewOfFile (const std::string &file)
Map a view of file into the applications address space.

void | unmapViewOfFile ()
Unmap the current view and close the corresponding file.

virtual NBFSAVER_API void | setViewState (const nvsg::ViewState *viewState)
Set a valid ViewState.

Protected Member Functions

bool | calculatingStorageRequirements () const
Determine whether the current traverser pass is calculating storage requirements.

uint_t | alloc (void *&ptr, size_t numBytes)
Allocate a portion of the currently mapped file into the process' address space.

void | dealloc (ubyte_t *offsetPtr)
Deallocate a portion of memory that is currently mapped to a file.

uint_t | pseudoAlloc (size_t numBytes)
Add numBytes to the currently calculated file size.

virtual void | doApply (const nvsg::Scene *scene)
Controls saving of the scene together with a ViewState.

virtual void | handleParallelCamera (const nvsg::ParallelCamera *p, const nvsg::Node *root)
Routine to handle a ParallelCamera object while traversing the scene graph.

virtual void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p, const nvsg::Node *root)
Routine to handle a PerspectiveCamera object while traversing the scene graph.

virtual void | handleBillboard (const nvsg::Billboard *p)
Routine to handle a Billboard node while traversing the scene graph.

virtual void | handleGeoNode (const nvsg::GeoNode *p)
Routine to handle a GeoNode while traversing the scene graph.

virtual void | handleGroup (const nvsg::Group *p)
Routine to handle a Group node while traversing the scene graph.

virtual void | handleTransform (const nvsg::Transform *p)
Routine to handle a Transform node while traversing the scene graph.

virtual void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Routine to handle a AnimatedTransform node while traversing the scene graph.

virtual void | handleLOD (const nvsg::LOD *p)
Routine to handle a LOD (Level Of Detail) node while traversing the scene graph.

virtual void | handleSwitch (const nvsg::Switch *p)
Routine to handle a Switch node while traversing the scene graph.

virtual void | handleDirectedLight (const nvsg::DirectedLight *p)
Routine to handle a DirectedLight node while traversing the scene graph.

virtual void | handlePointLight (const nvsg::PointLight *p)
Routine to handle a PointLight node while traversing the scene graph.

virtual void | handleSpotLight (const nvsg::SpotLight *p)
Routine to handle a SpotLight node while traversing the scene graph.

virtual void | handleStateSet (const nvsg::StateSet *p)
Routine to handle a StateSet object while traversing the scene graph.

virtual void | handleStateVariant (const nvsg::StateVariant *p)
Routine to handle a StateVariant object while traversing the scene graph.

virtual void | handleStatePass (const nvsg::StatePass *p)
Routine to handle a StatePass object while traversing the scene graph.

virtual void | handleBlendAttribute (const nvsg::BlendAttribute *p)
Routine to handle a BlendAttribute attribute while traversing the scene graph.

virtual void | handleCgFx (const nvsg::CgFx *p)
Routine to handle a CgFx attribute while traversing the scene graph.

virtual void | handleDepthAttribute (const nvsg::DepthAttribute *p)
Routine to handle a DepthAttribute attribute while traversing the scene graph.

virtual void | handleFaceAttribute (const nvsg::FaceAttribute *p)
Routine to handle a FaceAttribute attribute while traversing the scene graph.

virtual void | handleLineAttribute (const nvsg::LineAttribute *p)
Routine to handle a LineAttribute attribute while traversing the scene graph.

virtual void | handleMaterial (const nvsg::Material *p)
Routine to handle a Material attribute while traversing the scene graph.

virtual void | handlePointAttribute (const nvsg::PointAttribute *p)
Routine to handle a PointAttribute attribute while traversing the scene graph.

virtual void | handleTextureAttribute (const nvsg::TextureAttribute *p)
Routine to handle a TextureAttribute attribute while traversing the scene graph.

virtual void | handleTextureAttributeItem (const nvsg::TextureAttributeItem *p, size_t tu)
Routine to handle a TextureAttributeItem object while traversing the scene graph.

virtual void | handleTriangles (const nvsg::Triangles *p)
Routine to handle a Triangles object while traversing the scene graph.

virtual void | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Routine to handle a AnimatedTriangles object while traversing the scene graph.

virtual void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Routine to handle a SkinnedTriangles object while traversing the scene graph.

virtual void | handleTriFans (const nvsg::TriFans *p)
Routine to handle a TriFans object while traversing the scene graph.

virtual void | handleTriStrips (const nvsg::TriStrips *p)
Routine to handle a TriStrips object while traversing the scene graph.

virtual void | handleQuadMeshes (const nvsg::QuadMeshes *p)
Routine to handle a QuadMeshes object while traversing the scene graph.

virtual void | handleQuads (const nvsg::Quads *p)
Routine to handle a Quads object while traversing the scene graph.

virtual void | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Routine to handle a AnimatedQuads object while traversing the scene graph.

virtual void | handleQuadStrips (const nvsg::QuadStrips *p)
Routine to handle a QuadStrips object while traversing the scene graph.

virtual void | handleLines (const nvsg::Lines *p)
Routine to handle a Lines object while traversing the scene graph.

virtual void | handleLineStrips (const nvsg::LineStrips *p)
Routine to handle a LineStrips object while traversing the scene graph.

virtual void | handlePoints (const nvsg::Points *p)
Routine to handle a Points object while traversing the scene graph.

virtual void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
Routine to handle a VertexAttributeSet object while traversing the scene graph.

virtual void | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *p)
Routine to handle a FramedAnimation<Trafo> object while traversing the scene graph.

virtual void | handleFramedVNVectorAnimation (const nvsg::FramedAnimation< nvsg::VNVector > *p)
Routine to handle a FramedAnimation<VNVector> object while traversing the scene graph.

virtual void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p)
Routine to handle a LinearInterpolatedAnimation<Trafo> object while traversing the scene graph.

virtual void | handleLinearInterpolatedVNVectorAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p)
Routine to handle a LinearInterpolatedAnimation<VNVector> object while traversing the scene graph.

Detailed Description

A Traverser to traverse a scene on saving to "NBF" binary file format.

Constructor & Destructor Documentation

NBFSaveTraverser ( )

Default constructor.

Member Function Documentation

void preCalculateFileSize ( const nvsg::Scene * scene )

pre-calculate what the file size would be

bool mapViewOfFile ( const std::string & file )

Map a view of file into the applications address space.

void unmapViewOfFile ( )

Unmap the current view and close the corresponding file.

virtual NBFSAVER_API void setViewState ( const nvsg::ViewState * viewState ) [virtual]

Set a valid ViewState.

Set the ViewState to work with.

Parameters:
viewState pointer to a valid ViewState.

bool calculatingStorageRequirements ( ) const [protected]

Determine whether the current traverser pass is calculating storage requirements.

While saving a scene, the scene graph will be traversed twice. The first pass is to calculate storage requirements. Only the second pass really 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.

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.

uint_t alloc | ( | void *& | ptr,
 |  | size_t | numBytes
 | ) | [protected]

Allocate a portion of the currently mapped file into the process' address space.

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.

Returns:
The file offset of the mapped memory block.
Note:
The behavior is undefined if called while the current traverser pass is calculating storage requirements. While saving a scene, the scene graph will be traversed twice. The first pass is to calculate storage requirements. Only the second pass really writes the scene data to a file that has been mapped into the process' address space by the framework. Call calculatingStorageRequirements inside a handler routine to determine whether the current pass is to just calculate storage requirements.
Parameters:
ptr | Points to the mapped memory block after the call suceeded.
numBytes | Amount of bytes to be mapped into the process' address space.

void dealloc ( ubyte_t * offsetPtr ) [protected]

Deallocate a portion of memory that is currently mapped to a file.

Note: The memory, which is part of a potentially larger file mapping, actually won't be freed until that file mapping is unused (unreferenced).

Parameters:
offsetPtr The mapped memory address

uint_t pseudoAlloc ( size_t numBytes ) [protected]

Add numBytes to the currently calculated file size.

The function doesnt allocate anything, it just adds numBytes to the currently calculated file size.

Returns:
0
Note:
While saving a scene, the scene graph will be traversed twice. The first pass is to calculate storage requirements. Only the second pass really writes the scene data to a file that has been mapped into the process' address space by the framework. Call calculatingStorageRequirements inside a handler routine to determine whether the current pass is to just calculate storage requirements.
Parameters:
numBytes Number of bytes to be added to the currently calculated file size.

virtual void doApply ( const nvsg::Scene * scene ) [protected, virtual]

Controls saving of the scene together with a ViewState.

Parameters:
scene Scene to save

Reimplemented from Traverser.

virtual void handleParallelCamera | ( | const nvsg::ParallelCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Routine to handle a ParallelCamera object while traversing the scene graph.

This routine gets called for each ParallelCamera object that will be visited while traversing the scene graph. The currently visited ParallelCamera object is pointed to by p. If the root node pointed to by root is valid (that is, root is not a null pointer), this function traverses the root node after the camera settings have been evaluated. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handlePerspectiveCamera | ( | const nvsg::PerspectiveCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Routine to handle a PerspectiveCamera object while traversing the scene graph.

This routine gets called for each PerspectiveCamera object that will be visited while traversing the scene graph. The currently visited PerspectiveCamera object is pointed to by p. If the root node pointed to by root is valid (that is, root is not a null pointer), this function traverses the root node after the camera settings have been evaluated. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Routine to handle a Billboard node while traversing the scene graph.

This routine gets called for each Billboard object that will be visited while traversing the scene graph. The currently visited Billboard object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode while traversing the scene graph.

This routine gets called for each GeoNode object that will be visited while traversing the scene graph. The currently visited GeoNode object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Routine to handle a Group node while traversing the scene graph.

This routine gets called for each Group object that will be visited while traversing the scene graph. The currently visited Group object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

During child traversal you must not change the number or the position of children. Overload and use postTraverseGroup() for this.

Reimplemented from Traverser.

virtual void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Routine to handle a Transform node while traversing the scene graph.

This routine gets called for each Transform object that will be visited while traversing the scene graph. The currently visited Transform object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Routine to handle a AnimatedTransform node while traversing the scene graph.

This routine gets called for each AnimatedTransform object that will be visited while traversing the scene graph. The currently visited AnimatedTransform object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Routine to handle a LOD (Level Of Detail) node while traversing the scene graph.

This routine gets called for each LOD object that will be visited while traversing the scene graph. The currently visited LOD object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Routine to handle a Switch node while traversing the scene graph.

This routine gets called for each Switch object that will be visited while traversing the scene graph. The currently visited Switch object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleDirectedLight ( const nvsg::DirectedLight * p ) [protected, virtual]

Routine to handle a DirectedLight node while traversing the scene graph.

This routine gets called for each DirectedLight object that will be visited while traversing the scene graph. The currently visited DirectedLight object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handlePointLight ( const nvsg::PointLight * p ) [protected, virtual]

Routine to handle a PointLight node while traversing the scene graph.

This routine gets called for each PointLight object that will be visited while traversing the scene graph. The currently visited PointLight object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleSpotLight ( const nvsg::SpotLight * p ) [protected, virtual]

Routine to handle a SpotLight node while traversing the scene graph.

This routine gets called for each SpotLight object that will be visited while traversing the scene graph. The currently visited SpotLight object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Routine to handle a StateSet object while traversing the scene graph.

This routine gets called for each StateSet object that will be visited while traversing the scene graph. The currently visited StateSet object is pointed to by p. The base implementation ensures that the currently active StateVariant will be traversed. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Routine to handle a StateVariant object while traversing the scene graph.

This routine gets called for each StateVariant object that will be visited while traversing the scene graph. The currently visited StateVariant object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Routine to handle a StatePass object while traversing the scene graph.

This routine gets called for each StatePass object that will be visited while traversing the scene graph. The currently visited StatePass object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleBlendAttribute ( const nvsg::BlendAttribute * p ) [protected, virtual]

Routine to handle a BlendAttribute attribute while traversing the scene graph.

This routine gets called for each BlendAttribute object that will be visited while traversing the scene graph. The currently visited BlendAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Routine to handle a CgFx attribute while traversing the scene graph.

This routine gets called for each CgFx object that will be visited while traversing the scene graph. The currently visited CgFx object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleDepthAttribute ( const nvsg::DepthAttribute * p ) [protected, virtual]

Routine to handle a DepthAttribute attribute while traversing the scene graph.

This routine gets called for each DepthAttribute object that will be visited while traversing the scene graph. The currently visited DepthAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Routine to handle a FaceAttribute attribute while traversing the scene graph.

This routine gets called for each FaceAttribute object that will be visited while traversing the scene graph. The currently visited FaceAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleLineAttribute ( const nvsg::LineAttribute * p ) [protected, virtual]

Routine to handle a LineAttribute attribute while traversing the scene graph.

This routine gets called for each LineAttribute object that will be visited while traversing the scene graph. The currently visited LineAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleMaterial ( const nvsg::Material * p ) [protected, virtual]

Routine to handle a Material attribute while traversing the scene graph.

This routine gets called for each Material object that will be visited while traversing the scene graph. The currently visited Material object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handlePointAttribute ( const nvsg::PointAttribute * p ) [protected, virtual]

Routine to handle a PointAttribute attribute while traversing the scene graph.

This routine gets called for each PointAttribute object that will be visited while traversing the scene graph. The currently visited PointAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Routine to handle a TextureAttribute attribute while traversing the scene graph.

This routine gets called for each TextureAttribute object that will be visited while traversing the scene graph. The currently visited TextureAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | size_t | tu
 | ) | [protected, virtual]

Routine to handle a TextureAttributeItem object while traversing the scene graph.

This routine gets called for each TextureAttributeItem object that will be visited while traversing the scene graph. The currently visited TextureAttributeItem object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Routine to handle a Triangles object while traversing the scene graph.

This routine gets called for each Triangles object that will be visited while traversing the scene graph. The currently visited Triangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Routine to handle a AnimatedTriangles object while traversing the scene graph.

This routine gets called for each AnimatedTriangles object that will be visited while traversing the scene graph. The currently visited AnimatedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Routine to handle a SkinnedTriangles object while traversing the scene graph.

This routine gets called for each SkinnedTriangles object that will be visited while traversing the scene graph. The currently visited SkinnedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Routine to handle a TriFans object while traversing the scene graph.

This routine gets called for each TriFans object that will be visited while traversing the scene graph. The currently visited TriFans object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Routine to handle a TriStrips object while traversing the scene graph.

This routine gets called for each TriStrips object that will be visited while traversing the scene graph. The currently visited TriStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Routine to handle a QuadMeshes object while traversing the scene graph.

This routine gets called for each QuadMeshes object that will be visited while traversing the scene graph. The currently visited QuadMeshes object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Routine to handle a Quads object while traversing the scene graph.

This routine gets called for each Quads object that will be visited while traversing the scene graph. The currently visited Quads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Routine to handle a AnimatedQuads object while traversing the scene graph.

This routine gets called for each AnimatedQuads object that will be visited while traversing the scene graph. The currently visited AnimatedQuads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Routine to handle a QuadStrips object while traversing the scene graph.

This routine gets called for each QuadStrips object that will be visited while traversing the scene graph. The currently visited QuadStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Routine to handle a Lines object while traversing the scene graph.

This routine gets called for each Lines object that will be visited while traversing the scene graph. The currently visited Lines object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Routine to handle a LineStrips object while traversing the scene graph.

This routine gets called for each LineStrips object that will be visited while traversing the scene graph. The currently visited LineStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Routine to handle a Points object while traversing the scene graph.

This routine gets called for each Points object that will be visited while traversing the scene graph. The currently visited Points object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Routine to handle a VertexAttributeSet object while traversing the scene graph.

This routine gets called for each VertexAttributeSet object that will be visited while traversing the scene graph. The currently visited VertexAttributeSet object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleFramedTrafoAnimation ( const nvsg::FramedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Routine to handle a FramedAnimation<Trafo> object while traversing the scene graph.

This routine gets called for each FramedAnimation<Trafo> object that will be visited while traversing the scene graph. The currently visited FramedAnimation<Trafo> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleFramedVNVectorAnimation ( const nvsg::FramedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Routine to handle a FramedAnimation<VNVector> object while traversing the scene graph.

This routine gets called for each FramedAnimation<VNVector> object that will be visited while traversing the scene graph. The currently visited FramedAnimation<VNVector> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleLinearInterpolatedTrafoAnimation ( const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Routine to handle a LinearInterpolatedAnimation<Trafo> object while traversing the scene graph.

This routine gets called for each LinearInterpolatedAnimation<Trafo> object that will be visited while traversing the scene graph. The currently visited LinearInterpolatedAnimation<Trafo> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual void handleLinearInterpolatedVNVectorAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Routine to handle a LinearInterpolatedAnimation<VNVector> object while traversing the scene graph.

This routine gets called for each LinearInterpolatedAnimation<VNVector> object that will be visited while traversing the scene graph. The currently visited LinearInterpolatedAnimation<VNVector> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • NBFSaver.h
Generated on Fri Aug 4 08:36:52 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
alloc(void *&ptr, size_t numBytes) | NBFSaveTraverser | [protected]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
calculatingStorageRequirements() const | NBFSaveTraverser | [protected]
dealloc(ubyte_t *offsetPtr) | NBFSaveTraverser | [protected]
doApply(const nvsg::Scene *scene) | NBFSaveTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | NBFSaveTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | NBFSaveTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | NBFSaveTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | NBFSaveTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | NBFSaveTraverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | NBFSaveTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | NBFSaveTraverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | NBFSaveTraverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | NBFSaveTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | NBFSaveTraverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | NBFSaveTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | NBFSaveTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | NBFSaveTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | NBFSaveTraverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | NBFSaveTraverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | NBFSaveTraverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | NBFSaveTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | NBFSaveTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | NBFSaveTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | NBFSaveTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | NBFSaveTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | NBFSaveTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | NBFSaveTraverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | NBFSaveTraverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | NBFSaveTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | NBFSaveTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | NBFSaveTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | NBFSaveTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | NBFSaveTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | NBFSaveTraverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | NBFSaveTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | NBFSaveTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | NBFSaveTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | NBFSaveTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | NBFSaveTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | NBFSaveTraverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | NBFSaveTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | NBFSaveTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | NBFSaveTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | NBFSaveTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | NBFSaveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
mapViewOfFile(const std::string &file) | NBFSaveTraverser |
markUnshareable() | RCObject | [inline]
NBFSaveTraverser() | NBFSaveTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preCalculateFileSize(const nvsg::Scene *scene) | NBFSaveTraverser |
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
pseudoAlloc(size_t 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]
setViewState(const nvsg::ViewState *viewState) | NBFSaveTraverser | [virtual]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
unmapViewOfFile() | NBFSaveTraverser |
VIEWSIZE enum value (defined in NBFSaveTraverser) | NBFSaveTraverser |
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:36:52 2006 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.

float3_t backColor
Specifies the scene's RGB background color used with rendering.

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.

float3_t backColor

Specifies the scene's RGB background color used with rendering.

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 Fri Aug 4 08:36:52 2006 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
cameraAnimations | NBFScene
cameras | NBFScene
numberOfAnimationFrames | NBFScene
numCameraAnimations | NBFScene
numCameras | NBFScene
root | NBFScene
Generated on Fri Aug 4 08:36:52 2006 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 Fri Aug 4 08:36:53 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFPrimitiveSet
NBFDrawable::PADDING(3) | NBFObject
skins | NBFSkinnedTriangles
sourceObject | NBFObject
vertexAttributeSet | NBFPrimitiveSet
Generated on Fri Aug 4 08:36:53 2006 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.

Reimplemented from NBFObject.

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 Fri Aug 4 08:36:53 2006 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
annotation (defined in NBFNode) | NBFNode
attenuation | NBFSpotLight
castShadow | NBFLightSource
cutoffAngle | NBFSpotLight
diffuseColor | NBFLightSource
direction | NBFSpotLight
falloffExponent | NBFSpotLight
intensity | NBFLightSource
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFSpotLight
NBFLightSource::PADDING(3) | NBFLightSource
NBFNode::PADDING(6) | NBFNode
position | NBFSpotLight
sourceObject | NBFObject
specularColor | NBFLightSource
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:53 2006 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 Fri Aug 4 08:36:54 2006 for NVSGSDK by NVIDIA


Member List

NBFStateAttribute Member List

This is the complete list of members for NBFStateAttribute, including all inherited members.
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:54 2006 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 Fri Aug 4 08:36:54 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
stateAttribs | NBFStatePass
Generated on Fri Aug 4 08:36:54 2006 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.

Reimplemented from NBFObject.

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 Fri Aug 4 08:36:55 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFStateSet
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:55 2006 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 Fri Aug 4 08:36:55 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
statePasses | NBFStateVariant
Generated on Fri Aug 4 08:36:55 2006 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 Fri Aug 4 08:36:56 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFPrimitiveSet
NBFDrawable::PADDING(3) | NBFObject
sourceObject | NBFObject
strips | NBFStrippedPrimitiveSet
vertexAttributeSet | NBFPrimitiveSet
Generated on Fri Aug 4 08:36:56 2006 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 Attributes

uint_t numActiveChildren
Specifies the number of children that are currently switched on.

uint_t activeChildren

Detailed Description

The NBFSwitch structure represents a switch group node.

The object code for a NBFSwitch is NBF_SWITCH.

Member Data Documentation

uint_t numActiveChildren

Specifies the number of children that are currently switched on.

uint_t activeChildren

Specifies the offset to indices to the active children. < Indices are stored as 32-bit unsigned integers.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:56 2006 for NVSGSDK by NVIDIA


Member List

NBFSwitch Member List

This is the complete list of members for NBFSwitch, including all inherited members.
activeChildren | NBFSwitch
annotation (defined in NBFNode) | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
numActiveChildren | NBFSwitch
numChildren | NBFGroup
numClipPlanes | NBFGroup
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
NBFObject::PADDING(4) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
userHints | NBFNode
Generated on Fri Aug 4 08:36:56 2006 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 Fri Aug 4 08:36:57 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
Generated on Fri Aug 4 08:36:57 2006 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.

float4_t texEnvColor
Specifies the texture environment color.

uint_t texEnvMode
uint_t texWrapS
uint_t texWrapT
uint_t texWrapR
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.

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 texWrapS

Specifies the wrap parameter for texture coordinate s. < Valid values are TWM_REPEAT, TWM_CLAMP, and TWM_MIRROR

uint_t texWrapT

Specifies the wrap parameter for texture coordinate t. < Valid values are TWM_REPEAT, TWM_CLAMP, and TWM_MIRROR

uint_t texWrapR

Specifies the wrap parameter for texture coordinate r. < Valid values are TWM_REPEAT, TWM_CLAMP, and TWM_MIRROR

uint_t minFilter

Specifies the filter used with minimizing. < Valid values are TFM_MIN_NEAREST, TFM_MIN_BILINEAR, and TFM_MIN_TRILINEAR.

uint_t magFilter

Specifies the filter used with magnifying. < Valid values are TFM_MAX_NEAREST, and TFM_MAZ_BILINEAR.

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 Fri Aug 4 08:36:57 2006 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
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
texBorderColor | NBFTextureAttributeItem
texEnvColor | NBFTextureAttributeItem
texEnvMode | NBFTextureAttributeItem
texGenMode | NBFTextureAttributeItem
texGenPlane | NBFTextureAttributeItem
texImg | NBFTextureAttributeItem
texWrapR | NBFTextureAttributeItem
texWrapS | NBFTextureAttributeItem
texWrapT | NBFTextureAttributeItem
trafo | NBFTextureAttributeItem
Generated on Fri Aug 4 08:36:57 2006 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.

Reimplemented from NBFObject.

Reimplemented in NBFFramedTrafoAnimation.

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 Fri Aug 4 08:36:58 2006 for NVSGSDK by NVIDIA


Member List

NBFTrafoAnimation Member List

This is the complete list of members for NBFTrafoAnimation, including all inherited members.
isShared | NBFObject
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFTrafoAnimation
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
trafos | NBFTrafoAnimation
Generated on Fri Aug 4 08:36:58 2006 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

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 from NBFObject.

Reimplemented in NBFAnimatedTransform.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:58 2006 for NVSGSDK by NVIDIA


Member List

NBFTransform Member List

This is the complete list of members for NBFTransform, including all inherited members.
annotation (defined in NBFNode) | NBFNode
children | NBFGroup
clipPlanes | NBFGroup
isShared | NBFObject
numChildren | NBFGroup
numClipPlanes | NBFGroup
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(4) | NBFTransform
NBFGroup::PADDING(6) | NBFNode
NBFObject::PADDING(3) | NBFObject
sourceObject | NBFObject
systemHints | NBFNode
trafo (defined in NBFTransform) | NBFTransform
userHints | NBFNode
Generated on Fri Aug 4 08:36:58 2006 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 numVertices
Specifies the number of contained vertices.

uint_t vertices
Specifies the file offset to the vertices. Vertices are stored as float3_t.

uint_t numNormals
Specifies the number of contained normals.

uint_t normals
Specifies the file offset to the normals. Normals are stored as float3_t.

uint_t numTexCoordsSets
Specifies the number of contained texture coordinate sets.

uint_t texCoordsSets
uint_t numColors
Specifies the number of contained primary colors.

uint_t colorDim
uint_t colors
uint_t numSecondaryColors
Specifies the number of contained secondary colors.

uint_t secondaryColorDim
uint_t secondaryColors
uint_t numFogCoords
Specifies the number of contained fog coordinates.

uint_t fogCoords

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 numVertices

Specifies the number of contained vertices.

uint_t vertices

Specifies the file offset to the vertices. Vertices are stored as float3_t.

uint_t numNormals

Specifies the number of contained normals.

uint_t normals

Specifies the file offset to the normals. Normals are stored as float3_t.

uint_t numTexCoordsSets

Specifies the number of contained texture coordinate sets.

uint_t texCoordsSets

Specifies the file offset to the texture coordinate sets. < Texture coordinate sets are stored using the texCoordSet_t type.

uint_t numColors

Specifies the number of contained primary colors.

uint_t colorDim

Specifies the dimension, in terms of float, used for the primary colors. < Colors can be either three or four dimensional.

uint_t colors

Specifies the file offset to the primary colors. In conformity to the color's dimension, < colors are stored as float3_t or float4_t respectively.

uint_t numSecondaryColors

Specifies the number of contained secondary colors.

uint_t secondaryColorDim

Specifies the dimension, in terms of float, used for the secondary colors. < Colors can be either three or four dimensional.

uint_t secondaryColors

Specifies the file offset to the secondary colors. In conformity to the color's dimension, < colors are stored as float3_t or float4_t respectively.

uint_t numFogCoords

Specifies the number of contained fog coordinates.

uint_t fogCoords

Specifies the file offset to the fog coordinates. Fog coordinates always are one < dimensional, and are stored as 32-bit floating point values.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:36:59 2006 for NVSGSDK by NVIDIA


Member List

NBFVertexAttributeSet Member List

This is the complete list of members for NBFVertexAttributeSet, including all inherited members.
colorDim | NBFVertexAttributeSet
colors | NBFVertexAttributeSet
fogCoords | NBFVertexAttributeSet
isShared | NBFObject
normals | NBFVertexAttributeSet
numColors | NBFVertexAttributeSet
numFogCoords | NBFVertexAttributeSet
numNormals | NBFVertexAttributeSet
numSecondaryColors | NBFVertexAttributeSet
numTexCoordsSets | NBFVertexAttributeSet
numVertices | NBFVertexAttributeSet
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
secondaryColorDim | NBFVertexAttributeSet
secondaryColors | NBFVertexAttributeSet
sourceObject | NBFObject
texCoordsSets | NBFVertexAttributeSet
vertices | NBFVertexAttributeSet
Generated on Fri Aug 4 08:36:59 2006 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 (1)
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 isJitter
Indicates whether the view is in jitter mode.

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 numJitters
Specifies the number of jitter values available.

uint_t jitters
Specifies the offset to the float2_t jitter values used with jitter mode on.

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 ( 1 )

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 isJitter

Indicates whether the view is in jitter mode.

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 numJitters

Specifies the number of jitter values available.

uint_t jitters

Specifies the offset to the float2_t jitter values used with jitter mode on.

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 Fri Aug 4 08:36:59 2006 for NVSGSDK by NVIDIA


Member List

NBFViewState Member List

This is the complete list of members for NBFViewState, including all inherited members.
camera | NBFViewState
isJitter | NBFViewState
isStereo | NBFViewState
isStereoAutomatic | NBFViewState
jitters | NBFViewState
numJitters | NBFViewState
objectCode | NBFViewState
PADDING(1) | NBFViewState
stereoAutomaticFactor | NBFViewState
stereoEyeDistance | NBFViewState
targetDistance | NBFViewState
Generated on Fri Aug 4 08:36:59 2006 for NVSGSDK by NVIDIA


NBFVNVectorAnimation Struct Reference

The NBFVNVectorAnimation represents an animation that will be applied to VNVector objects. More...

#include <NBF.h>

Inheritance diagram for NBFVNVectorAnimation:

[legend]
Collaboration diagram for NBFVNVectorAnimation:

[legend]
List of all members.

Public Attributes

uint_t numVertices
uint_t vertexSets
uint_t numNormals
uint_t normalSets

Detailed Description

The NBFVNVectorAnimation represents an animation that will be applied to VNVector objects.

A NBFVNVectorAnimation serves as base class only and needs to be considered in conjunction with either NBFFramedAnimation or NBFInterpolatedAnimation.
Concrete object codes valid for a NBFVNVectorAnimation are NBF_FRAMED_VNVECTOR_ANIMATION, and NBF_LINEAR_INTERPOLATED_VNVECTOR_ANIMATION. Further concrete object codes valid for NBFVNVectorAnimation objects are subject to future extensions of the NBF format.

Member Data Documentation

uint_t numVertices

Specifies the number of vertices per vertex set. Each vertex set of < the actual animation is specified to have the same count of vertices.

uint_t vertexSets

Specifies the file offset to the pre-transformed vertex sets for this animation. < The vertex sets are stored adjoined to each other in contiguous memory.
< The actual number of vertex sets, as well as normal sets, is specified by < the corresponding animation type, which is either NBFFramedAnimation or < NBFInterpolatedAnimation.

uint_t numNormals

Specifies the number of normals per normal set. Each normal set of < the actual animation is specified to have the same count of normals.

uint_t normalSets

Specifies the file offset to the pre-transformed normal sets for this animation. < The normal sets are stored adjoined to each other in contiguous memory.
< The actual number of normal sets, as well as vertex sets, 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 Fri Aug 4 08:36:59 2006 for NVSGSDK by NVIDIA


Member List

NBFVNVectorAnimation Member List

This is the complete list of members for NBFVNVectorAnimation, including all inherited members.
isShared | NBFObject
normalSets | NBFVNVectorAnimation
numNormals | NBFVNVectorAnimation
numVertices | NBFVNVectorAnimation
objectCode | NBFObject
objectDataID | NBFObject
objectName | NBFObject
PADDING(3) | NBFObject
PADDING(4) | NBFObject
sourceObject | NBFObject
vertexSets | NBFVNVectorAnimation
Generated on Fri Aug 4 08:36:59 2006 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

virtual NVSG_API const Node * | clone () const=0
Returns a deep-copy of this Node object.

NVSG_API size_t | getNumberOfParents () const
Returns the number of parent Group nodes for this Node.

NVSG_API const Group * | getParent (size_t index) const
Returns a parent Group by index.

NVSG_API const nvmath::Sphere3f & | getBoundingSphere () const
Returns the Node's bounding sphere.

NVSG_API void | invalidateBoundingSphere ()
Invalidates the Node's bounding sphere.

NVSG_API bool | containsTransparentGeometry () const
Tests whether the Node contains transparent geometry.

NVSG_API void | invalidateTransparencyContainment ()
Invalidates the transparency containment cache.

virtual NVSG_API bool | containsCgFx () const
Tests whether the Node contains CgFx attributes.

virtual NVSG_API void | invalidateCgFxContainment ()
Invalidates the CgFx containment cache.

virtual NVSG_API bool | containsLight () const
Tests whether the Node contains a LightSource.

virtual NVSG_API void | invalidateLightContainment ()
Invalidates the Light containment cache.

virtual NVSG_API size_t | getNumberOfFrames () const
Returns the number of animation frames contained.

virtual NVSG_API void | invalidateNumberOfFrames () const
Invalidates the cache for the number of frames contained.

NVSG_API void | setAnnotation (const std::string &anno)
Specifies an annotation to be appended to this Node.

NVSG_API const std::string & | getAnnotation () const
Retrieves the Node's annotation.

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 void | invalidateHintsContainment (unsigned short hints)
Invalidates the containment flags for a set of hints.

NVSG_API void | assertInvalidBoundingSphere () const
Prompts an assertion failed message if the Node's bounding box is valid.

Protected Member Functions

NVSG_API | Node (void)
Constructs a Node.

NVSG_API | Node (const Node &rhs)
Constructs a Node as a copy of another Node.

virtual NVSG_API | ~Node (void)
Destructs a Node.

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 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.

NVSG_API Node & | operator= (const Node &rhs)
Assigns new content from another Node.

virtual NVSG_API void | invalidateIncarnation ()
Overrides Object::invalidateIncarnation.

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:
    Node * pNode = beginEdit( pConstantNode );
    pNode->addHints( NH_CULL_NEVER );
    endEdit( pNode );
Example
To change the culling hint back to the default state, do the following:
    Node * pNode = beginEdit( pConstantNode );
    pNode->removeHints( NH_CULL_MASK );
    endEdit( pNode );
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 ( void ) [protected]

Constructs a Node.

Remarks:
This default constructor is accessible only by Node-derived classes.

NVSG_API Node ( const Node & rhs ) [protected]

Constructs a Node as a copy of another Node.

Remarks:
This copy constructor is accessible only by Node-derived classes.

virtual NVSG_API ~Node ( void ) [protected, virtual]

Destructs a Node.

Remarks:
This destructor is accessible only by Node-derived classes.

Member Function Documentation

virtual NVSG_API const Node* clone ( ) const [pure virtual]

Returns a deep-copy of this Node object.

Returns:
The function returns a pointer to the Node that was created as a copy of this Node.
Remarks:
The parent Group nodes of this node will not be copied as this would result in an entire tree copy. That is, the new clone initially is not part of the tree but a stand-alone Node. For the new Node to become a tree Node, it needs to be added to a particular Group or Group-derived object within the tree through Group::addChild.

The implementation of this function is required for concrete Node-derived classes for proper cloning of the particular objects.

Implemented in AnimatedTransform, Billboard, DirectedLight, GeoNode, Group, LightSource, LOD, PointLight, SpotLight, Switch, and Transform.

size_t 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.

const Group * getParent ( size_t 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 nodes 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::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 invalidateBoundingSphere ( )

Invalidates the Node's bounding sphere.

Remarks:
The function invalidates this Node's bounding sphere and that of all nodes up the hierarchy. This forces a re-calculation of the bounding sphere the next time the Node's bounding sphere will be queried through Node::getBoundingSphere.

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

NVSG_API void invalidateTransparencyContainment ( )

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.

virtual NVSG_API bool containsCgFx ( ) const [virtual]

Tests whether the Node contains CgFx attributes.

Returns:
The function returns true if the Node contains CgFx attributes. Otherwise, the function returns false.
Remarks:
The function iterates through the underlying hierarchy to detect CgFx attributes. 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::invalidateCgFxContainment

Reimplemented in GeoNode, and Group.

virtual NVSG_API void invalidateCgFxContainment ( ) [virtual]

Invalidates the CgFx containment cache.

Remarks:
The function invalidates this Node's CgFx 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::containsCgFx.

Reimplemented in GeoNode, and Group.

virtual NVSG_API bool containsLight ( ) const [virtual]

Tests whether the Node contains a LightSource.

Returns:
The function returns true if the Node contains at least one LightSource. Otherwise, the function returns false.
Remarks:
The function iterates through the underlying hierarchy to detect LightSources. 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 LightSources will be added to or removed from the Node.
See also:
Node::invalidateLightContainment

Reimplemented in Group, and LightSource.

virtual NVSG_API void invalidateLightContainment ( ) [virtual]

Invalidates the Light containment cache.

Remarks:
The function invalidates this Node's Light 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::containsLight.

Reimplemented in Group.

virtual NVSG_API size_t getNumberOfFrames ( ) const [virtual]

Returns the number of animation frames contained.

Returns:
The function returns the actual number of contained animation frames.
Remarks:
The function iterates the underlying hierarchy for animations to query for the number of frames. As this might be an expensive operation, the result of the test will be cached to provide faster access with the next queries. If the animation state changes underneath this Group, the cache will become invalid, forcing a re-calculation of the result the very next query.

There currently is a restriction that a Scene can contain animations with only the exact same number of frames.
See also:
Node::invalidateNumberOfFrames

Reimplemented in AnimatedTransform, GeoNode, Group, and LightSource.

virtual NVSG_API void invalidateNumberOfFrames ( ) const [virtual]

Invalidates the cache for the number of frames contained.

Remarks:
The function invalidates this Nodes's cache for the number of frames contained and that of all Nodes up the hierarchy. This forces a re-calculation of these caches with the very next query through Node::getNumberOfFrames.

Reimplemented in GeoNode, and Group.

NVSG_API void setAnnotation ( const std::string & anno )

Specifies an annotation to be appended to this Node.

Parameters:
anno Reference to a STL string that holds the annotation to set.
Remarks:
The function lets you append an optional annotation as wanted.
See also:
Node::getAnnotation

NVSG_API const std::string& getAnnotation ( ) const

Retrieves the Node's annotation.

Returns:
The function returns a reference to a STL string holding the annotation as specified through Node::setAnnotation. If no annotation was previously specified, the function returns an empty string.
See also:
Node::setAnnotation

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:
If not for all hints in hints the containment is valid, determineHintsContainment is called that determines and validates the containment of the hints.
See also:
getHints, setHints, addHints, removeHints, invalidateHintsContainment

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

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::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, LightSource, Switch, and Transform.

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 containsHints is called while the hint containment flags mark that information as invalid.
See also:
containsHints, invalidateHintsContainment

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, LightSource, and Switch.

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.

virtual NVSG_API void invalidateIncarnation ( ) [protected, 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.

The documentation for this class was generated from the following file:
  • Node.h
Generated on Fri Aug 4 08:38:17 2006 for NVSGSDK by NVIDIA


Member List

Node Member List

This is the complete list of members for Node, including all inherited members.
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const=0 | Node | [protected, pure virtual]
clone() const=0 | Node | [pure virtual]
containsCgFx() const | Node | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Node | [virtual]
containsTransparentGeometry() const | Node |
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineTransparencyContainment() const=0 | Node | [protected, pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames() const | Node | [virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCgFxContainment() | Node | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Node | [virtual]
invalidateNumberOfFrames() const | Node | [virtual]
invalidateTransparencyContainment() | Node |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAnnotation(const std::string &anno) | Node |
setHints(unsigned short hints) | Node | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:17 2006 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 size_t | getVertexAttributeIndex () const
Get the index of the VertexAttributeSet that is to be normalized.

NVSG_API void | setVertexAttributeIndex (size_t 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 (const nvsg::Scene *scene)
Initiate traversal of the scene.

void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
Unify all VertexAttributeSets.

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

size_t getVertexAttributeIndex ( ) const [inline]

Get the index of the VertexAttributeSet that is to be normalized.

The default index for normalizing is NORMAL.

void setVertexAttributeIndex ( size_t 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 ( const nvsg::Scene * scene ) [protected, virtual]

Initiate traversal of the scene.

Reimplemented from Traverser.

void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Unify all VertexAttributeSets.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • NormalizeTraverser.h
Generated on Fri Aug 4 08:39:26 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | NormalizeTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
getVertexAttributeIndex() const | NormalizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | NormalizeTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NormalizeTraverser(void) | NormalizeTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setVertexAttributeIndex(size_t attrib) | NormalizeTraverser | [inline]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~NormalizeTraverser(void) | NormalizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:26 2006 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 Attributes

size_t | nullNormalsCount
The number of objects with null normals.

size_t | 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

Member Data Documentation

size_t nullNormalsCount

The number of objects with null normals.

size_t nullNormalsNumber

The number of null normals in those objects.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:05 2006 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() (defined in NullNormalsResult) | NullNormalsResult | [inline, virtual]
Generated on Fri Aug 4 08:39:05 2006 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.

const nvsg::Scene * | load (const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&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.

const nvsg::Scene * load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | const nvsg::ViewState *& | viewState
 | ) | [inline]

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.

The documentation for this class was generated from the following file:
  • NVBLoader.h
Generated on Fri Aug 4 08:37:00 2006 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]
deleteThis(void) | NVBLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&viewState) | NVBLoader | [inline]
nvsg::SceneLoader::load(const std::string &filename, const std::vector< std::string > &searchPaths, const ViewState *&viewState)=0 | SceneLoader | [pure 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 Fri Aug 4 08:37:00 2006 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< const nvsg::Material * > &faceMappedMaterials)
Constructor.

virtual | ~NVBLoadTraverser (void)
Destructor.

Protected Member Functions

virtual void | handleCgFx (const nvsg::CgFx *p)
Postprocessing on CgFx.

virtual void | handleGeoNode (const nvsg::GeoNode *p)
Postprocessing on GeoNode.

virtual void | handleLOD (const nvsg::LOD *p)
Postprocessing on LOD: Shouldn't be called at any time !

virtual void | handleMaterial (const nvsg::Material *p, bool reset)
Postprocessing on Material.

virtual void | handleStateSet (const nvsg::StateSet *p)
Postprocessing on StateSet.

virtual void | handleSwitch (const nvsg::Switch *p)
Postprocessing on Switch: Shouldn't be called at any time !

virtual void | handleTriangles (const 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< const nvsg::Material * > & faceMappedMaterials )

Constructor.

virtual ~NVBLoadTraverser ( void ) [virtual]

Destructor.

Member Function Documentation

virtual void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Postprocessing on CgFx.

Just stores that a StateAttribute of type CgFx is encountered.

Reimplemented from Traverser.

virtual void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Postprocessing on GeoNode.

Traverses the GeoNode p and clears the state of encountering a CgFx.

Reimplemented from Traverser.

virtual void handleLOD ( const nvsg::LOD * p ) [inline, protected, virtual]

Postprocessing on LOD: Shouldn't be called at any time !

Reimplemented from Traverser.

virtual void handleMaterial | ( | const nvsg::Material * | p,
 |  | bool | reset
 | ) | [protected, virtual]

Postprocessing on Material.

Stores the current Material for later references in a GeoSet.

virtual void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Postprocessing on StateSet.

Clears the current Material and traverses the StateSet p.

Reimplemented from Traverser.

virtual void handleSwitch ( const nvsg::Switch * p ) [inline, protected, virtual]

Postprocessing on Switch: Shouldn't be called at any time !

Reimplemented from Traverser.

virtual void handleTriangles ( const 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 Traverser.

The documentation for this class was generated from the following file:
  • NVBLoadTraverser.h
Generated on Fri Aug 4 08:37:01 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | Traverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | NVBLoadTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | NVBLoadTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | NVBLoadTraverser | [inline, protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p, bool reset) | NVBLoadTraverser | [protected, virtual]
nvtraverser::Traverser::handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | NVBLoadTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | NVBLoadTraverser | [inline, protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | NVBLoadTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVBLoadTraverser(std::vector< const nvsg::Material * > &faceMappedMaterials) | NVBLoadTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~NVBLoadTraverser(void) | NVBLoadTraverser | [virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:37:01 2006 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

const nvsg::Scene * | load (const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&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

const nvsg::Scene * load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | const nvsg::ViewState *& | viewState
 | ) | [inline]

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 Fri Aug 4 08:37:02 2006 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, const nvsg::ViewState *&viewState) | NVNVB | [inline]
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 Fri Aug 4 08:37:02 2006 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 Fri Aug 4 08:37:48 2006 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 Fri Aug 4 08:37:48 2006 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 Fri Aug 4 08:37:02 2006 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 Fri Aug 4 08:37:02 2006 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.

const nvsg::Scene * | load (const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&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.

const nvsg::Scene* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | const nvsg::ViewState *& | viewState
 | ) |

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.

The documentation for this class was generated from the following file:
  • NVSGLoader.h
Generated on Fri Aug 4 08:37:03 2006 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]
deleteThis(void) | NVSGLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&viewState) | NVSGLoader |
nvsg::SceneLoader::load(const std::string &filename, const std::vector< std::string > &searchPaths, const ViewState *&viewState)=0 | SceneLoader | [pure 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 Fri Aug 4 08:37:03 2006 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 Fri Aug 4 08:37:03 2006 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 Fri Aug 4 08:37:03 2006 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 (const nvsg::Scene &scene, const nvsg::ViewState *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 | ( | const nvsg::Scene & | scene,
 |  | const nvsg::ViewState * | viewState,
 |  | const std::string & | filename
 | ) |

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

The documentation for this class was generated from the following file:
  • NVSGSaver.h
Generated on Fri Aug 4 08:37:04 2006 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]
deleteThis(void) | NVSGSaver | [inline, virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(const nvsg::Scene &scene, const nvsg::ViewState *viewState, const std::string &filename) | NVSGSaver |
nvsg::SceneSaver::save(const Scene &scene, const ViewState *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 Fri Aug 4 08:37:04 2006 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.

virtual NVSGSAVER_API void | setViewState (const nvsg::ViewState *viewState)
Set a valid ViewState.

Protected Member Functions

void | doApply (const nvsg::Scene *scene)
Controls saving of the scene together with a ViewState.

virtual void | handleParallelCamera (const nvsg::ParallelCamera *p, const nvsg::Node *root)
Save a ParallelCamera.

virtual void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p, const nvsg::Node *root)
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 | handleGroup (const nvsg::Group *p)
Save a Group.

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 | 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, size_t tu)
Save a TextureAttributeItem.

virtual void | handleTriangles (const nvsg::Triangles *p)
Save a Triangles.

virtual void | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Save a AnimatedTriangles.

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 | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Save a AnimatedQuads.

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 | handleFramedTrafoAnimation (const nvsg::FramedAnimation< nvmath::Trafo > *p)
Save a FramedTrafoAnimation.

virtual void | handleFramedVNVectorAnimation (const nvsg::FramedAnimation< nvsg::VNVector > *p)
Save a FramedVNVectorAnimation.

virtual void | handleLinearInterpolatedTrafoAnimation (const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p)
Save a LinearInterpolatedTrafoAnimation.

virtual void | handleLinearInterpolatedVNVectorAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p)
Save a LinearInterpolatedVNVectorAnimation.

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

virtual NVSGSAVER_API void setViewState ( const nvsg::ViewState * viewState ) [virtual]

Set a valid ViewState.

Set the ViewState to work with.

Note:
This traverser needs a valid ViewState. Call setViewState prior to apply().
Parameters:
viewState pointer to a valid ViewState.

void doApply ( const nvsg::Scene * scene ) [protected, virtual]

Controls saving of the scene together with a ViewState.

Note:
This version ignores the ViewState and the Tweakables of the CgFx objects.
Parameters:
scene Scene to save

Reimplemented from Traverser.

virtual void handleParallelCamera | ( | const nvsg::ParallelCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [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 Traverser.

virtual void handlePerspectiveCamera | ( | const nvsg::PerspectiveCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

virtual void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | size_t | tu
 | ) | [protected, virtual]

Save a TextureAttributeItem.

If the TextureAttributeItem p is encountered on saving the first time, it is saved.

Reimplemented from Traverser.

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 Traverser.

virtual void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Save a AnimatedTriangles.

If the AnimatedTriangles p is encountered on saving the first time, any associated Animation is traversed, then it is saved.

Reimplemented from Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

virtual void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Save a AnimatedQuads.

If the AnimatedQuads p is encountered on saving the first time, any associated Animation is traversed, then it is saved.

Reimplemented from Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

virtual void handleFramedVNVectorAnimation ( const nvsg::FramedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Save a FramedVNVectorAnimation.

If the FramedVNVectorAnimation p is encountered on saving the first time, it is saved.

Reimplemented from Traverser.

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 Traverser.

virtual void handleLinearInterpolatedVNVectorAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Save a LinearInterpolatedVNVectorAnimation.

If the LinearInterpolatedVNVectorAnimation p is encountered on saving the first time, it is saved.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • NVSGSaver.h
Generated on Fri Aug 4 08:37:05 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | NVSGSaveTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | NVSGSaveTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | NVSGSaveTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | NVSGSaveTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | NVSGSaveTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [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]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | NVSGSaveTraverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | NVSGSaveTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | NVSGSaveTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | NVSGSaveTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | NVSGSaveTraverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *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 *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | NVSGSaveTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | NVSGSaveTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | 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 *p) | Traverser | [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, size_t 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]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | NVSGSaveTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
NVSGSaveTraverser() | NVSGSaveTraverser |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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 |
setViewState(const nvsg::ViewState *viewState) | NVSGSaveTraverser | [virtual]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:37:05 2006 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

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.

NVSG_API void | increaseIncarnation ()
Increases the Incarnation count of this particular object.

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.

virtual NVSG_API bool | isEquivalent (const Object *object, bool ignoreNames=true, bool deepCompare=false) const
Tests whether this object is equivalent to another object.

Protected 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.

NVSG_API Object & | operator= (const Object &rhs)
Assigns new content from another Object.

virtual NVSG_API void | validateIncarnation () const
Marks the Incarnation of this Object as valid.

virtual NVSG_API void | invalidateIncarnation ()
Marks the Incarnation of this Object as invalid.

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 ( ) [protected]

Constructs an Object.

Remarks:
This default constructor is accessible only by Object-derived classes.

NVSG_API Object ( const Object & rhs ) [protected]

Constructs an Object as a copy of another Object.

Remarks:
This copy constructor is accessible only by Object-derived classes.

virtual NVSG_API ~Object ( ) [protected, virtual]

Destructs an Object.

Remarks:
This destructor is accessible only by Object-derived classes.

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 NVSG Core Classes 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:
Object::increaseIncarnation

NVSG_API void increaseIncarnation ( )

Increases the Incarnation count of this particular object.

Remarks:
If a particular object gets modified, it must call this function for all owning objects to increase the Incarnation counter of all objects up the hierarchy (bottom to top). This is necessary to enable users to encounter changes without iterating down a tree hierarchy.
See also:
Object::invalidateIncarnation, Object::validateIncarnation

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.

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 AnimatedQuads, AnimatedTransform, AnimatedTriangles, Billboard, BlendAttribute, CgFx, DepthAttribute, FaceAttribute, FramedAnimation, GeoNode, Group, IndependentPrimitiveSet, InterpolatedAnimation, LightSource, LineAttribute, LOD, Material, MeshedPrimitiveSet, PointAttribute, PointLight, PrimitiveSet, Shape, SkinnedTriangles, SpotLight, StatePass, StateSet, StateVariant, StrippedPrimitiveSet, Switch, TextureAttributeItem, TextureAttribute, Transform, VertexAttributeSet, FramedAnimation< nvmath::Trafo >, and InterpolatedAnimation< nvmath::Trafo >.

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.

virtual NVSG_API void validateIncarnation ( ) const [protected, virtual]

Marks the Incarnation of this Object as valid.

Remarks:
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:
Object::invalidateIncarnation

Reimplemented in AnimatedQuads, AnimatedTransform, AnimatedTriangles, Camera, Drawable, GeoNode, Group, LightSource, MapArray, MapElement, MapList, MapMatrix, PrimitiveSet, Shape, SkinnedTriangles, StatePass, StateSet, StateVariant, and TextureAttribute.

virtual NVSG_API void invalidateIncarnation ( ) [protected, virtual]

Marks the Incarnation of this Object as invalid.

Remarks:
If the Incarnation of the object is valid, the default implementation first increments the Incarnation count and then marks it 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:
Object::invalidateIncarnation

Reimplemented in Drawable, Node, StateAttribute, StatePass, StateSet, StateVariant, TextureAttributeItem, and VertexAttributeSet.

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 Fri Aug 4 08:38:18 2006 for NVSGSDK by NVIDIA


Member List

Object Member List

This is the complete list of members for Object, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getObjectCode() const | Object | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Object &rhs) | Object | [protected]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:18 2006 for NVSGSDK by NVIDIA


TemplateOffset_AutoPtr class Reference

Offset_AutoPtr Class Template Reference

An auxiliary helper template class which serves for exception save mapping and unmapping of file offsets. More...

#include <NBFLoader.h>

Collaboration diagram for Offset_AutoPtr:

[legend]
List of all members.

Public Member Functions

Offset_AutoPtr (NBFLoader *ldr, uint_t offset, size_t count=1)
Maps the specified file offset into process memory.

~Offset_AutoPtr ()
Unmaps the bytes, that have been mapped at instantiation, from process memory.

T * | operator-> () const
Provides pointer-like access to the dumb pointer.

T & | operator * () const
De-references the dumb pointer.

operator const T * () const
Implicit conversion to const T*.

void | reset (uint_t offset, size_t count=1)
Resets the object to map another file offset.

Offset_AutoPtr (NBFSaveTraverser *svr, uint_t &fileOffset, size_t count=1)
Maps the specified file offset into process memory.

Offset_AutoPtr (NBFSaveTraverser *svr)
Constructor.

~Offset_AutoPtr ()
Unmaps the bytes, that have been mapped at instantiation, from process memory.

T * | operator-> ()
Provides pointer-like access to the dumb pointer.

T & | operator * ()
De-references the dumb pointer.

operator T * ()
Implicit conversion to const T*.

void | alloc (uint_t &fileOffset, size_t count=1)
Allocate the pointer object.

Detailed Description

template<typename T>
class Offset_AutoPtr< T >

An auxiliary helper template class which serves for exception save mapping and unmapping of file offsets.

The purpose of this template class is to turn a mapped offset into an exception safe auto object, that is - the mapped offset automatically gets unmapped if the object runs out of scope.

Constructor & Destructor Documentation

Offset_AutoPtr | ( | NBFLoader * | ldr,
 |  | uint_t | offset,
 |  | size_t | count = 1
 | ) | [inline]

Maps the specified file offset into process memory.

This constructor is called on instantiation. It maps count objects of type T at file offset offset into process memory.

~Offset_AutoPtr ( ) [inline]

Unmaps the bytes, that have been mapped at instantiation, from process memory.

Offset_AutoPtr | ( | NBFSaveTraverser * | svr,
 |  | uint_t & | fileOffset,
 |  | size_t | count = 1
 | ) | [inline]

Maps the specified file offset into process memory.

This constructor is called on instantiation. It maps count objects of type T at file offset offset into process memory.

Offset_AutoPtr ( NBFSaveTraverser * svr ) [inline]

Constructor.

This constructor does not allocate any mapping space yet. Use the alloc() member function, to initialize the pointer later.

~Offset_AutoPtr ( ) [inline]

Unmaps the bytes, that have been mapped at instantiation, from process memory.

Member Function Documentation

T* operator-> ( ) const [inline]

Provides pointer-like access to the dumb pointer.

T& operator * ( ) const [inline]

De-references the dumb pointer.

operator const T * ( ) const [inline]

Implicit conversion to const T*.

void reset | ( | uint_t | offset,
 |  | size_t | count = 1
 | ) | [inline]

Resets the object to map another file offset.

The function first unmaps previously mapped bytes and after that maps count T objects at file offset offset into process memory.

T* operator-> ( ) [inline]

Provides pointer-like access to the dumb pointer.

T& operator * ( ) [inline]

De-references the dumb pointer.

operator T * ( ) [inline]

Implicit conversion to const T*.

void alloc | ( | uint_t & | fileOffset,
 |  | size_t | count = 1
 | ) | [inline]

Allocate the pointer object.

This function can be used to create the mapping later, when using the constructor that does not allocate any space yet.

The documentation for this class was generated from the following files:
  • NBFLoader.h
  • NBFSaver.h
Generated on Fri Aug 4 08:37:06 2006 for NVSGSDK by NVIDIA


Member List

Offset_AutoPtr Member List

This is the complete list of members for Offset_AutoPtr, including all inherited members.
alloc(uint_t &fileOffset, size_t count=1) | Offset_AutoPtr | [inline]
Offset_AutoPtr(NBFLoader *ldr, uint_t offset, size_t count=1) | Offset_AutoPtr | [inline]
Offset_AutoPtr(NBFSaveTraverser *svr, uint_t &fileOffset, size_t count=1) | Offset_AutoPtr | [inline]
Offset_AutoPtr(NBFSaveTraverser *svr) | Offset_AutoPtr | [inline]
operator *() const | Offset_AutoPtr | [inline]
operator *() | Offset_AutoPtr | [inline]
operator const T *() const | Offset_AutoPtr | [inline]
operator T *() | Offset_AutoPtr | [inline]
operator->() const | Offset_AutoPtr | [inline]
operator->() | Offset_AutoPtr | [inline]
reset(uint_t offset, size_t count=1) | Offset_AutoPtr | [inline]
~Offset_AutoPtr() | Offset_AutoPtr | [inline]
~Offset_AutoPtr() | Offset_AutoPtr | [inline]
Generated on Fri Aug 4 08:37:06 2006 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 (const nvsg::Scene *scene)
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 ( const nvsg::Scene * scene ) [protected, virtual]

doApply override

Reimplemented from Traverser.

Reimplemented in GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODEliminateTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, StateSetUnifyTraverser, SwitchToGroupTraverser, VertexAttributeSetUnifyTraverser, and VertexUnifyTraverser.

The documentation for this class was generated from the following file:
  • OptimizeTraverser.h
Generated on Fri Aug 4 08:39:27 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | OptimizeTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:27 2006 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

virtual NVSG_API const ParallelCamera * | clone () const
Create a new ParallelCamera by copying from this.

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.

Static Public Member Functions

NVSG_API const ParallelCamera * | create ()
Create a ParallelCamera.

NVSG_API const ParallelCamera * | createFromBase (const Camera &rhs)
Create a ParallelCamera by copying from a Camera.

Protected Member Functions

NVSG_API | ParallelCamera ()
Protected constructor to prevent explicit creation.

NVSG_API | ParallelCamera (const Camera &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | ParallelCamera (const ParallelCamera &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~ParallelCamera ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside ParallelCamera::create.

NVSG_API ParallelCamera ( const Camera & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Camera to use as a base of the new ParallelCamera
Remarks:
This constructor is never used explicitly, but only inside ParallelCamera::createFromBase.
See also:
Camera

NVSG_API ParallelCamera ( const ParallelCamera & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant ParallelCamera to copy from
Remarks:
This constructor is never used explicitly, but only inside ParallelCamera::create.

virtual NVSG_API ~ParallelCamera ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the ParallelCamera is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const ParallelCamera* create ( ) [static]

Create a ParallelCamera.

Returns:
A pointer to a constant ParallelCamera.
Remarks:
A default ParallelCamera equals a default Camera.

NVSG_API const ParallelCamera* createFromBase ( const Camera & rhs ) [static]

Create a ParallelCamera by copying from a Camera.

Parameters:
rhs A reference to the constant Camera to copy from
Returns:
A pointer to a constant ParallelCamera.
Remarks:
All the data from the Camera rhs is used as the base information for the newly created ParallelCamera. A ParallelCamera does not own specific data, so the initialization is complete.
See also:
Camera

virtual NVSG_API const ParallelCamera* clone ( ) const [virtual]

Create a new ParallelCamera by copying from this.

Returns:
A pointer to a constant ParallelCamera.
Remarks:
The newly created ParallelCamera is an exact copy of this.

Implements Camera.

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 Fri Aug 4 08:38:19 2006 for NVSGSDK by NVIDIA


Member List

ParallelCamera Member List

This is the complete list of members for ParallelCamera, including all inherited members.
addHeadLight(const LightSource *light) | Camera |
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
calcNearFarDistances(const nvmath::Sphere3f &sphere) | Camera |
Camera(void) | Camera | [protected]
Camera(const Camera &rhs) | Camera | [protected]
clearHeadLights(void) | Camera |
clone() const | ParallelCamera | [virtual]
create() | ParallelCamera | [static]
createFromBase(const Camera &rhs) | ParallelCamera | [static]
determineCullCode(const nvmath::Sphere3f &sphere) const | ParallelCamera | [virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAspectRatio(void) const | Camera | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDirection(void) const | Camera | [inline]
getFarDistance(void) const | Camera | [inline]
getFocusDistance(void) const | Camera | [inline]
getHeadLight(size_t index) const | Camera | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInverseProjection() const | ParallelCamera | [virtual]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
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]
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 |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isAutoClipPlanes(void) const | Camera | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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 | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const ParallelCamera &rhs) | ParallelCamera |
nvsg::Camera::operator=(const Camera &rhs) | Camera | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [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 | [protected]
ParallelCamera(const Camera &rhs) | ParallelCamera | [explicit, protected]
ParallelCamera(const ParallelCamera &rhs) | ParallelCamera | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHeadLight(size_t index) | Camera |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
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]
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 |
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]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | Camera | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
zoom(float factor) | Camera | [inline]
zoom(const nvmath::Sphere3f &sphere, float fovy=-1.0f) | Camera |
~Camera(void) | Camera | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~ParallelCamera() | ParallelCamera | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:19 2006 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 const Object * | getHead () const
Get the head object of the path.

NVSG_API const Object * | getTail () const
Get the tail object of the path.

NVSG_API const Object * | getFromHead (size_t i) const
Get an object on the path.

NVSG_API const Object * | getFromTail (size_t i) const
Get an object on the path.

NVSG_API void | pop ()
Remove the last object from the path.

NVSG_API void | push (const Object *pObject)
Append an object to the path chain.

NVSG_API void | truncate (size_t 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:
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.

const Object * 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

const Object * 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

const Object * getFromHead ( size_t 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

const Object * getFromTail ( size_t 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 ( const Object * pObject )

Append an object to the path chain.

Parameters:
Pointer to an 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 ( size_t 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 Fri Aug 4 08:38:20 2006 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(size_t i) const | Path | [inline]
getFromTail(size_t 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, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
Path() | Path |
Path(const Path &rhs) | Path |
pop() | Path | [inline]
push(const Object *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(size_t start) | Path |
~IAllocator() | IAllocator | [inline, virtual]
~Path() | Path | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:20 2006 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

virtual NVSG_API const PerspectiveCamera * | clone () const
Create a new PerspectiveCamera by copying from this.

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.

Static Public Member Functions

NVSG_API const PerspectiveCamera * | create ()
Create a PerspectiveCamera.

NVSG_API const PerspectiveCamera * | createFromBase (const Camera &rhs)
Create a PerspectiveCamera by copying from a Camera.

Protected Member Functions

NVSG_API | PerspectiveCamera ()
Protected constructor to prevent explicit creation.

NVSG_API | PerspectiveCamera (const Camera &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | PerspectiveCamera (const PerspectiveCamera &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~PerspectiveCamera ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside PerspectiveCamera::create.

NVSG_API PerspectiveCamera ( const Camera & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Camera to use as a base of the new PerspectiveCamera
Remarks:
This constructor is never used explicitly, but only inside PerspectiveCamera::createFromBase.
See also:
Camera

NVSG_API PerspectiveCamera ( const PerspectiveCamera & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PerspectiveCamera to copy from
Remarks:
This constructor is never used explicitly, but only inside PerspectiveCamera::create.

virtual NVSG_API ~PerspectiveCamera ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the PerspectiveCamera is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const PerspectiveCamera* create ( ) [static]

Create a PerspectiveCamera.

Returns:
A pointer to a constant PerspectiveCamera.
Remarks:
A default PerspectiveCamera equals a default Camera.

NVSG_API const PerspectiveCamera* createFromBase ( const Camera & rhs ) [static]

Create a PerspectiveCamera by copying from a Camera.

Parameters:
rhs A reference to the constant Camera to copy from
Returns:
A pointer to a constant PerspectiveCamera.
Remarks:
All the data from the Camera rhs is used as the base information for the newly created PerspectiveCamera. A PerspectiveCamera does not own specific data, so the initialization is complete.
See also:
Camera

virtual NVSG_API const PerspectiveCamera* clone ( ) const [virtual]

Create a new PerspectiveCamera by copying from this.

Returns:
A pointer to a constant PerspectiveCamera.
Remarks:
The newly created PerspectiveCamera is an exact copy of this.

Implements Camera.

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 Fri Aug 4 08:38:21 2006 for NVSGSDK by NVIDIA


Member List

PerspectiveCamera Member List

This is the complete list of members for PerspectiveCamera, including all inherited members.
addHeadLight(const LightSource *light) | Camera |
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
calcNearFarDistances(const nvmath::Sphere3f &sphere) | Camera |
Camera(void) | Camera | [protected]
Camera(const Camera &rhs) | Camera | [protected]
clearHeadLights(void) | Camera |
clone() const | PerspectiveCamera | [virtual]
create() | PerspectiveCamera | [static]
createFromBase(const Camera &rhs) | PerspectiveCamera | [static]
determineCullCode(const nvmath::Sphere3f &sphere) const | PerspectiveCamera | [virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAspectRatio(void) const | Camera | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDirection(void) const | Camera | [inline]
getFarDistance(void) const | Camera | [inline]
getFieldOfView() const | PerspectiveCamera | [inline]
getFocusDistance(void) const | Camera | [inline]
getHeadLight(size_t index) const | Camera | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInverseProjection() const | PerspectiveCamera | [virtual]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
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]
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 |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation() | Object | [protected, virtual]
isAutoClipPlanes(void) const | Camera | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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 | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const PerspectiveCamera &rhs) | PerspectiveCamera |
nvsg::Camera::operator=(const Camera &rhs) | Camera | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [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 | [protected]
PerspectiveCamera(const Camera &rhs) | PerspectiveCamera | [explicit, protected]
PerspectiveCamera(const PerspectiveCamera &rhs) | PerspectiveCamera | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHeadLight(size_t index) | Camera |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
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]
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 |
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]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation(void) const | Camera | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
zoom(float factor) | Camera | [inline]
zoom(const nvmath::Sphere3f &sphere, float fovy=-1.0f) | Camera |
~Camera(void) | Camera | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PerspectiveCamera() | PerspectiveCamera | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:21 2006 for NVSGSDK by NVIDIA


Plane3f Class Reference

Plane class. More...

#include <Plane3f.h>

Collaboration diagram for Plane3f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Plane3f (void)
Default constructor.

NVSG_API | Plane3f (const Vec3f &n, float c)
Constructor by normal and offset.

NVSG_API | Plane3f (const Vec3f &n, const Vec3f &p)
Constructor by normal and point on plane.

NVSG_API | Plane3f (const Vec3f &p0, const Vec3f &p1, const Vec3f &p2)
Constructor by three points.

NVSG_API Plane3f | operator- (void) const
Negation operator.

NVSG_API Plane3f & | operator= (const Plane3f &pl)
Assignment operator.

NVSG_API bool | operator== (const Plane3f &pl) const
Equality operator.

NVSG_API bool | operator!= (const Plane3f &pl) const
Inequality operator.

NVSG_API float | operator() (const Vec3f &p) const
Calling operator.

NVSG_API Vec3f & | n (void)
Non-constant access to the plane normal.

NVSG_API const Vec3f & | n (void) const
Constant access to the plane normal.

NVSG_API float & | c (void)
Non-constant access to the plane offset.

NVSG_API const float & | c (void) const
Constant access to the plane offset.

Related Functions

(Note that these are not member functions.)

bool | areOnOppositeSides (const Plane3f &plane, const Vec3f &p0, const Vec3f &p1)
bool | areOnSameSide (const Plane3f &plane, const Vec3f &p0, const Vec3f &p1)
float | signedDistance (const Plane3f &pl, const Vec3f &p)
float | distance (const Plane3f &pl, const Vec3f &p)
Vec3f | nearestPoint (const Plane3f &pl, const Vec3f &p)

Detailed Description

Plane class.

This represents a plane in 3-space. It's defined by a normal n and an offset c, such that for any point x in the plane, the equation

 n x + c = 0
holds.

Constructor & Destructor Documentation

NVSG_API Plane3f ( void )

Default constructor.

For performance reasons no initialization is performed.

NVSG_API Plane3f | ( | const Vec3f & | n,
 |  | float | c
 | ) |

Constructor by normal and offset.

Parameters:
n | normal
c | offset

NVSG_API Plane3f | ( | const Vec3f & | n,
 |  | const Vec3f & | p
 | ) |

Constructor by normal and point on plane.

Parameters:
n | normal
p | point in plane

NVSG_API Plane3f | ( | const Vec3f & | p0,
 |  | const Vec3f & | p1,
 |  | const Vec3f & | p2
 | ) |

Constructor by three points.

Member Function Documentation

Plane3f operator- ( void ) const [inline]

Negation operator.

Returns:
complementary plane (with reversed normal).

Plane3f & operator= ( const Plane3f & pl ) [inline]

Assignment operator.

Returns:
reference to the assigned plane
Parameters:
pl plane to assign

bool operator== ( const Plane3f & pl ) const [inline]

Equality operator.

Two planes are considered to be equal, if the normals are equal and the offsets differ by less than epsilon.

Returns:
true if the plane is equal to pl, otherwise false
Parameters:
pl plane to compare with

bool operator!= ( const Plane3f & pl ) const [inline]

Inequality operator.

Two planes are considered to be equal, if the normals are equal and the offsets differ by less than epsilon.

Returns:
true if the plane is not equal to pl, otherwise false
Parameters:
pl plane to compare with

NVSG_API float operator() ( const Vec3f & p ) const

Calling operator.

The point p is set into the plane equation, that is the signed distance of the point to the plane is calculated.

Returns:
the signed distance of p to the plane.
Parameters:
p point to determine distance from plane

Vec3f & n ( void ) [inline]

Non-constant access to the plane normal.

Returns:
reference to the plane normal.

const Vec3f & n ( void ) const [inline]

Constant access to the plane normal.

Returns:
constant reference to the plane normal.

float & c ( void ) [inline]

Non-constant access to the plane offset.

Returns:
reference to the plane offset.

const float & c ( void ) const [inline]

Constant access to the plane offset.

Returns:
constant reference to the plane offset.

Friends And Related Function Documentation

bool areOnOppositeSides | ( | const Plane3f & | plane,
 |  | const Vec3f & | p0,
 |  | const Vec3f & | p1
 | ) | [related]

Determine if two points are on opposite sides of a plane.

Returns:
true, if p0 and p1 are on opposite sides of plane.
Parameters:
plane | plane to use
p0 | first point
p1 | second point

bool areOnSameSide | ( | const Plane3f & | plane,
 |  | const Vec3f & | p0,
 |  | const Vec3f & | p1
 | ) | [related]

Determine if two points are on the same side of a plane.

Returns:
true, if p0 and p1 are on the same side of plane.
Parameters:
plane | plane to use
p0 | first point
p1 | second point

float signedDistance | ( | const Plane3f & | pl,
 |  | const Vec3f & | p
 | ) | [related]

Determine signed distance between the Plane pl and the Point p.

Returns:
signed distance between pl and p.
Parameters:
pl | plane
p | point

float distance | ( | const Plane3f & | pl,
 |  | const Vec3f & | p
 | ) | [related]

Determine distance between the Plane pl and the Point p.

Returns:
distance between pl and p.
Parameters:
pl | plane
p | point

Vec3f nearestPoint | ( | const Plane3f & | pl,
 |  | const Vec3f & | p
 | ) | [related]

Determine the point on the plane pl nearest to the point p.

Returns:
the point on the plane pl nearest to the point p.
Parameters:
pl | plane
p | point

The documentation for this class was generated from the following file:
  • Plane3f.h
Generated on Fri Aug 4 08:37:22 2006 for NVSGSDK by NVIDIA


Member List

Plane3f Member List

This is the complete list of members for Plane3f, including all inherited members.
areOnOppositeSides(const Plane3f &plane, const Vec3f &p0, const Vec3f &p1) | Plane3f | [related]
areOnSameSide(const Plane3f &plane, const Vec3f &p0, const Vec3f &p1) | Plane3f | [related]
c(void) | Plane3f | [inline]
c(void) const | Plane3f | [inline]
distance(const Plane3f &pl, const Vec3f &p) | Plane3f | [related]
n(void) | Plane3f | [inline]
n(void) const | Plane3f | [inline]
nearestPoint(const Plane3f &pl, const Vec3f &p) | Plane3f | [related]
operator!=(const Plane3f &pl) const | Plane3f | [inline]
operator()(const Vec3f &p) const | Plane3f |
operator-(void) const | Plane3f | [inline]
operator=(const Plane3f &pl) | Plane3f | [inline]
operator==(const Plane3f &pl) const | Plane3f | [inline]
Plane3f(void) | Plane3f |
Plane3f(const Vec3f &n, float c) | Plane3f |
Plane3f(const Vec3f &n, const Vec3f &p) | Plane3f |
Plane3f(const Vec3f &p0, const Vec3f &p1, const Vec3f &p2) | Plane3f |
signedDistance(const Plane3f &pl, const Vec3f &p) | Plane3f | [related]
Generated on Fri Aug 4 08:37:22 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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.

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, WRLLoader, NBFSaver, and NVSGSaver.

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 Fri Aug 4 08:40:11 2006 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]
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 Fri Aug 4 08:40:11 2006 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
}
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
}
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 void | onUnexpectedEndOfFile (size_t position) const
Specialized callback on error: PICE_UNEXPECTED_EOF.

virtual void | onUnexpectedToken (size_t position, const std::string &expected, const std::string &encountered) const
Specialized callback on error: PICE_UNEXPECTED_TOKEN.

virtual void | onUnknownToken (size_t position, const std::string &context, const std::string &token) const
Specialized callback on error: PICE_UNKNOWN_TOKEN.

virtual bool | onEmptyToken (size_t 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 (size_t position, const std::string &context, const std::string &token) const
Specialized callback on warning: PICW_UNDEFINED_TOKEN.

virtual bool | onIncompatibleValues (size_t 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 (size_t 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 (size_t position, const std::string &context, const std::string &valueName, int value) const
Specialized callback on warning: PICW_INVALID_VALUE.

virtual bool | onInvalidValue (size_t position, const std::string &context, const std::string &valueName, float value) const
Specialized callback on warning: PICW_INVALID_VALUE.

virtual bool | onUnsupportedToken (size_t position, const std::string &context, const std::string &token) const
Specialized callback on warning: PICW_UNSUPPORTED_TOKEN.

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 | onImcompatibleFile (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

void onUnexpectedEndOfFile ( size_t 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 | ( | size_t | 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 | ( | size_t | 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 | ( | size_t | 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 | ( | size_t | 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 | ( | size_t | 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 | ( | size_t | 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 | ( | size_t | 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 implementatino, 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 | ( | size_t | 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 implementatino, 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 | ( | size_t | 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 implementatino, 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

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 onImcompatibleFile | ( | 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 Fri Aug 4 08:40:12 2006 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]
onEmptyToken(size_t 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]
onImcompatibleFile(const std::string &file, const std::string &context, unsigned int expectedVersion, unsigned int detectedVersion) const | PlugInCallback | [inline, virtual]
onIncompatibleValues(size_t position, const std::string &context, const std::string &value0Name, int value0, const std::string &value1Name, int value1) const | PlugInCallback | [inline, virtual]
onIncompatibleValues(size_t 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(size_t position, const std::string &context, const std::string &valueName, int value) const | PlugInCallback | [inline, virtual]
onInvalidValue(size_t position, const std::string &context, const std::string &valueName, float value) const | PlugInCallback | [inline, virtual]
onUndefinedToken(size_t position, const std::string &context, const std::string &token) const | PlugInCallback | [inline, virtual]
onUnexpectedEndOfFile(size_t position) const | PlugInCallback | [inline, virtual]
onUnexpectedToken(size_t position, const std::string &expected, const std::string &encountered) const | PlugInCallback | [inline, virtual]
onUnknownToken(size_t position, const std::string &context, const std::string &token) const | PlugInCallback | [inline, virtual]
onUnsupportedToken(size_t 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, 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 |
PICT_FLOAT enum value (defined in PlugInCallback) | PlugInCallback |
PICT_INT 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_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 Fri Aug 4 08:40:12 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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

size_t | 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

size_t 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 Fri Aug 4 08:40:13 2006 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 Fri Aug 4 08:40:13 2006 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 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 "*.dll" on Microsoft(R) Windows platforms, and "*.so" 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 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 for all plug-ins that provide a certain interface type specified by pitid. If successfull, 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 successfull, false otherwise.
Parameters:
searchPath | The 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 Fri Aug 4 08:40:11 2006 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 Fri Aug 4 08:40:11 2006 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

virtual NVSG_API const PointAttribute * | clone () const
Create a new PointAttribute by copying from this.

NVSG_API bool | isAntiAliased () const
Get the antialiasing state.

NVSG_API void | setAntiAliasing (bool aa)
Set the antialiasing 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.

Static Public Member Functions

NVSG_API const PointAttribute * | create ()
Create a PointAttribute.

NVSG_API const PointAttribute * | createFromBase (const PrimitiveAttribute &rhs)
Create a PointAttribute by copying from a PrimitiveAttribute.

Protected Member Functions

NVSG_API | PointAttribute ()
Protected default constructor to prevent explicit creation.

NVSG_API | PointAttribute (const PrimitiveAttribute &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | PointAttribute (const PointAttribute &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~PointAttribute ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside PointAttribute::create.

NVSG_API PointAttribute ( const PrimitiveAttribute & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveAttribute to use as a base of the new PointAttribute
Remarks:
This constructor is never used explicitly, but only inside PointAttribute::createFromBase.
See also:
PrimitiveAttribute

NVSG_API PointAttribute ( const PointAttribute & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PointAttribute to copy from
Remarks:
This constructor is never used explicitly, but only inside PointAttribute::create.

virtual NVSG_API ~PointAttribute ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the PointAttribute is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const PointAttribute* create ( ) [static]

Create a PointAttribute.

Returns:
A pointer to a constant PointAttribute.
Remarks:
A PointAttribute with antialiasing off and point size 1.0 is created.

NVSG_API const PointAttribute* createFromBase ( const PrimitiveAttribute & rhs ) [static]

Create a PointAttribute by copying from a PrimitiveAttribute.

Parameters:
rhs A reference to the constant PrimitiveAttribute to copy from
Returns:
A pointer to a constant PointAttribute.
Remarks:
All the data from the PrimitiveAttribute rhs is used as the base information for the newly created PointAttribute. PointAttribute specific data is initialized as if PointAttribute::create was called.
See also:
PrimitiveAttribute

virtual NVSG_API const PointAttribute* clone ( ) const [virtual]

Create a new PointAttribute by copying from this.

Returns:
A pointer to a constant PointAttribute.
Remarks:
The newly created PointAttribute is an exact copy of this.

Implements StateAttribute.

bool isAntiAliased ( ) const [inline]

Get the antialiasing state.

Returns:
true, if antialiasing for Points is enabled, otherwise false.
Remarks:
With antialiasing 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, antialiasing is disabled.
See also:
getSize, setAntiAliasing

void setAntiAliasing ( bool aa ) [inline]

Set the antialiasing state.

Parameters:
aa true, if antialiasing is to be enabled, otherwise false.
Remarks:
With antialiasing 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, antialiasing 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 antialiasing 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 Fri Aug 4 08:38:24 2006 for NVSGSDK by NVIDIA


Member List

PointAttribute Member List

This is the complete list of members for PointAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | PointAttribute | [virtual]
create() | PointAttribute | [static]
createFromBase(const PrimitiveAttribute &rhs) | PointAttribute | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
getSize() const | PointAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isAntiAliased() const | PointAttribute | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | PointAttribute | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const PointAttribute &rhs) | PointAttribute |
nvsg::PrimitiveAttribute::operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PointAttribute() | PointAttribute | [protected]
PointAttribute(const PrimitiveAttribute &rhs) | PointAttribute | [explicit, protected]
PointAttribute(const PointAttribute &rhs) | PointAttribute | [protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAntiAliasing(bool aa) | PointAttribute | [inline]
setName(const std::string &name) | Object |
setSize(float size) | PointAttribute | [inline]
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PointAttribute() | PointAttribute | [protected, virtual]
~PrimitiveAttribute() | PrimitiveAttribute | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:38:24 2006 for NVSGSDK by NVIDIA


TemplatePointerReference class Reference

PointerReference Class Template Reference

Provides reference counting for pointers. More...

#include <RCObject.h>

Collaboration diagram for PointerReference:

[legend]
List of all members.

Public Member Functions

PointerReference (T *ptr)
Constructs a PointerReference.

void | addRef ()
Increments the reference count for the managed pointer by 1.

void | removeRef ()
Decrements the reference count for the managed pointer by 1.

bool | isShared () const
Tests whether the managed pointer is referenced more than once.

operator T * () const
Provides implicit conversion to a pointer to type T.

T * | operator-> () const
Dereferences a PointerReference object.

T & | operator * () const
Dereferences a PointerReference object.

bool | operator== (const T *ptr) const
Compares the dump pointer with another pointer.

bool | operator!= (const T *ptr) const
Compares the dump pointer with another pointer.

Detailed Description

template<typename T>
class nvutil::PointerReference< T >

Provides reference counting for pointers.

Namespace: nvutil
Remarks:
This class is a pointer object which lets you reference count ordinary pointers. In situations where a user needs to keep track of how often a certain pointer is referenced by some owning object, this class provides a simple interface for manipulating the reference count associated with a certain pointer.

Constructor & Destructor Documentation

PointerReference ( T * ptr ) [inline]

Constructs a PointerReference.

Parameters:
ptr Pointer to reference count.
Remarks:
The dump pointer will be initialized with the pointer value passed through ptr. The reference counter for the managed pointer will be initialized to 1.
Note:
A PointerReference must not be initialized with an invalid pointer. Doing so will certainly cause the dereference operators to crash.

Member Function Documentation

void addRef ( ) [inline]

Increments the reference count for the managed pointer by 1.

void removeRef ( ) [inline]

Decrements the reference count for the managed pointer by 1.

bool isShared ( ) const [inline]

Tests whether the managed pointer is referenced more than once.

Returns:
The function returns true if the managed pointer is referenced more than once. Otherwise the function returns false.

operator T * ( ) const [inline]

Provides implicit conversion to a pointer to type T.

Returns:
The function returns the managed pointer.
Remarks:
Wherever a pointer to type T is expected, a PointerReferenc<T> object can be passed. This operator implicitly converts this PointerReferenc<T> object to a pointer to type T.

T* operator-> ( ) const [inline]

Dereferences a PointerReference object.

Returns:
The function returns the managed pointer.
Remarks:
This operator helps a PointerReference object to behave like an ordinary pointer.
See also:
PointerReference::operator*()

T& operator * ( ) const [inline]

Dereferences a PointerReference object.

Returns:
The function returns a reference to the object pointed to by the managed pointer.
Remarks:
This operator helps a PointerReference object to behave like an ordinary pointer.
See also:
PointerReference::operator->()

bool operator== ( const T * ptr ) const [inline]

Compares the dump pointer with another pointer.

Returns:
The function returns true if the pointer values are equal. Otherwise, the function returns false.

bool operator!= ( const T * ptr ) const [inline]

Compares the dump pointer with another pointer.

Returns:
The function returns true if the pointer values are different. Otherwise, the function returns false.

The documentation for this class was generated from the following file:
  • RCObject.h
Generated on Fri Aug 4 08:40:18 2006 for NVSGSDK by NVIDIA


Member List

PointerReference Member List

This is the complete list of members for PointerReference, including all inherited members.
addRef() | PointerReference | [inline]
isShared() const | PointerReference | [inline]
operator *() const | PointerReference | [inline]
operator T *() const | PointerReference | [inline]
operator!=(const T *ptr) const | PointerReference | [inline]
operator->() const | PointerReference | [inline]
operator==(const T *ptr) const | PointerReference | [inline]
PointerReference(T *ptr) | PointerReference | [inline]
removeRef() | PointerReference | [inline]
Generated on Fri Aug 4 08:40:18 2006 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

virtual NVSG_API const PointLight * | clone () const
Create a new PointLight by copying from this.

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.

Static Public Member Functions

NVSG_API const PointLight * | create ()
Create a PointLight.

NVSG_API const PointLight * | createFromBase (const LightSource &rhs)
Create a PointLight by copying from a LightSource.

Protected Member Functions

NVSG_API | PointLight ()
Protected default constructor to prevent explicit creation.

NVSG_API | PointLight (const LightSource &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | PointLight (const PointLight &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~PointLight ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside PointLight::create.

NVSG_API PointLight ( const LightSource & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant LightSource to use as a base of the new PointLight
Remarks:
This constructor is never used explicitly, but only inside PointLight::createFromBase.
See also:
LightSource

NVSG_API PointLight ( const PointLight & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant PointLight to copy from
Remarks:
This constructor is never used explicitly, but only inside PointLight::create.

virtual NVSG_API ~PointLight ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the PointLight is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const PointLight* create ( ) [static]

Create a PointLight.

Returns:
A pointer to a constant PointLight.
Remarks:
A PointLight with default settings is created.
See also:
LightSource

NVSG_API const PointLight* createFromBase ( const LightSource & rhs ) [static]

Create a PointLight by copying from a LightSource.

Parameters:
rhs A reference to the constant LightSource to copy from
Returns:
A pointer to a constant PointLight.
Remarks:
All the data from the LightSource rhs is used as the base information for the newly created DirectedLight. PointLight specific data is initialized as if PointLight::create would have been called.
See also:
LightSource

virtual NVSG_API const PointLight* clone ( ) const [virtual]

Create a new PointLight by copying from this.

Returns:
A pointer to a constant PointLight.
Remarks:
The newly created PointLight is an exact copy of this.

Implements LightSource.

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

void setPosition ( const nvmath::Vec3f & position ) [inline]

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 reference to the constant 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 Fri Aug 4 08:38:25 2006 for NVSGSDK by NVIDIA


Member List

PointLight Member List

This is the complete list of members for PointLight, including all inherited members.
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | LightSource | [protected, virtual]
clone() const | PointLight | [virtual]
containsCgFx() const | Node | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | LightSource | [virtual]
containsTransparentGeometry() const | Node |
create() | PointLight | [static]
createFromBase(const LightSource &rhs) | PointLight | [static]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineTransparencyContainment() const | LightSource | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Node |
getAttenuation(float &c, float &l, float &q) const | PointLight | [inline]
getAttenuation() const | PointLight | [inline]
getBoundingSphere() const | Node |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDiffuseColor() const | LightSource | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames() const | LightSource | [inline, virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getPosition() const | PointLight | [inline]
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCgFxContainment() | Node | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Node | [virtual]
invalidateNumberOfFrames() const | Node | [virtual]
invalidateTransparencyContainment() | Node |
isAttenuated() const | PointLight | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | PointLight | [virtual]
isShadowCasting() const | LightSource | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const PointLight &rhs) | PointLight |
nvsg::LightSource::operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PointLight() | PointLight | [protected]
PointLight(const LightSource &rhs) | PointLight | [explicit, protected]
PointLight(const PointLight &rhs) | PointLight | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(const Animation< nvmath::Trafo > *animation) | LightSource |
setAnimationFrame(size_t frame) | LightSource |
setAnnotation(const std::string &anno) | Node |
setAttenuation(float c, float l, float q) | PointLight | [inline]
setAttenuation(const nvmath::Vec3f &attenuation) | PointLight | [inline]
setDiffuseColor(const nvmath::Vec3f &color) | LightSource | [inline]
setHints(unsigned short hints) | Node | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setPosition(const nvmath::Vec3f &position) | PointLight | [inline]
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | LightSource | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LightSource() | LightSource | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~PointLight() | PointLight | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:25 2006 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

virtual NVSG_API const Points * | clone () const
Create a new Points by copying from this.

NVSG_API Points & | operator= (const Points &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const Points * | create ()
Create a Points.

NVSG_API const Points * | createFromBase (const IndependentPrimitiveSet &rhs)
Create a Points by copying from an IndependentPrimitiveSet.

NVSG_API const Points * | createFromBase (const PrimitiveSet &rhs)
Create a Points by copying from a PrimitiveSet.

Protected Member Functions

NVSG_API | Points ()
Protected default constructor to prevent explicit creation.

NVSG_API | Points (const IndependentPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Points (const PrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Points (const Points &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Points ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Points::create.

NVSG_API Points ( const IndependentPrimitiveSet & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to use as a base of the new Points
Remarks:
This constructor is never used explicitly, but only inside Points::createFromBase.
See also:
IndependentPrimitiveSet

NVSG_API Points ( const PrimitiveSet & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveSet to use as a base of the new Points
Remarks:
This constructor is never used explicitly, but only inside Points::createFromBase.
See also:
PrimitiveSet

NVSG_API Points ( const Points & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Points to copy from
Remarks:
This constructor is never used explicitly, but only inside Points::create.

virtual NVSG_API ~Points ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Points is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Points* create ( ) [static]

Create a Points.

Returns:
A pointer to a constant Points.
Remarks:
Per default a Points is empty.

NVSG_API const Points* createFromBase ( const IndependentPrimitiveSet & rhs ) [static]

Create a Points by copying from an IndependentPrimitiveSet.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to copy from
Returns:
A pointer to a constant Points.
Remarks:
All the data from the IndependentPrimitiveSet rhs is used as the base information for the newly created Points. The indices provided with rhs are interpreted then as independent points.
See also:
IndependentPrimitiveSet

NVSG_API const Points* createFromBase ( const PrimitiveSet & rhs ) [static]

Create a Points by copying from a PrimitiveSet.

Parameters:
rhs A reference to the constant PrimitiveSet to copy from
Returns:
A pointer to a constant Points.
Remarks:
All the data from the PrimitiveSet rhs is used as the base information for the newly created Points. However, there are no indices provided, so there are no points in the new Points object.
See also:
IndependentPrimitiveSet

virtual NVSG_API const Points* clone ( ) const [virtual]

Create a new Points by copying from this.

Returns:
A pointer to a constant Points.
Remarks:
The newly created Points is an exact copy of this.

Implements IndependentPrimitiveSet.

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 Fri Aug 4 08:38:26 2006 for NVSGSDK by NVIDIA


Member List

Points Member List

This is the complete list of members for Points, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
clone() const | Points | [virtual]
create() | Points | [static]
createFromBase(const IndependentPrimitiveSet &rhs) | Points | [static]
createFromBase(const PrimitiveSet &rhs) | Points | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
Points() | Points | [protected]
Points(const IndependentPrimitiveSet &rhs) | Points | [explicit, protected]
Points(const PrimitiveSet &rhs) | Points | [explicit, protected]
Points(const Points &rhs) | Points | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~Points() | Points | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:26 2006 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.

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.

virtual NVSG_API | ~PrimitiveAttribute ()
Protected destructor 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

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.

virtual NVSG_API ~PrimitiveAttribute ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
This destructor 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 Fri Aug 4 08:38:27 2006 for NVSGSDK by NVIDIA


Member List

PrimitiveAttribute Member List

This is the complete list of members for PrimitiveAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone(void) const=0 | StateAttribute | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveAttribute() | PrimitiveAttribute | [protected]
PrimitiveAttribute(const PrimitiveAttribute &rhs) | PrimitiveAttribute | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveAttribute() | PrimitiveAttribute | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:38:27 2006 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

NVSG_API const VertexAttributeSet * | getVertexAttributeSet () const
Get a pointer to the constant VertexAttributeSet.

NVSG_API void | setVertexAttributeSet (const VertexAttributeSet *set)
Set the VertexAttributeSet.

NVSG_API bool | isCompatible (const PrimitiveSet *p, bool ignoreNames=true) 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 const PrimitiveSet * | clone () const=0
Interface for creating a new PrimitiveSet by copying from this.

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.

virtual NVSG_API | ~PrimitiveSet ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this PrimitiveSet.

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

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.

virtual NVSG_API ~PrimitiveSet ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
This destructor is accessible only by derived classes. The reference count of the VertexAttributeSet is decremented.

Member Function Documentation

const VertexAttributeSet * getVertexAttributeSet ( ) const [inline]

Get a pointer to the constant VertexAttributeSet.

Returns:
A pointer to the constant VertexAttributeSet.
See also:
VertexAttributeSet

NVSG_API void setVertexAttributeSet ( const VertexAttributeSet * set )

Set the VertexAttributeSet.

Parameters:
set 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

NVSG_API bool isCompatible | ( | const PrimitiveSet * | p,
 |  | bool | ignoreNames = true
 | ) | const

Test for compatibility with an other PrimitiveSet.

Parameters:
p | A reference to the constant PrimitiveSet to test for compatibility with.
ignoreNames | Optional parameter to ignore the names of the objects; default is true.
Returns:
true if the PrimitiveSet p is compatible with this, otherwise false.
Remarks:
p and this are compatible, if each of their vertex attributes have the same dimension, respectively.
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 AnimatedQuads, AnimatedTriangles, IndependentPrimitiveSet, MeshedPrimitiveSet, SkinnedTriangles, and StrippedPrimitiveSet.

virtual NVSG_API const PrimitiveSet* clone ( ) const [pure virtual]

Interface for creating a new PrimitiveSet by copying from this.

Returns:
A pointer to a constant PrimitiveSet.
Remarks:
The newly created PrimitiveSet should be an exact copy of this.

Implements Drawable.

Implemented in AnimatedQuads, AnimatedTriangles, IndependentPrimitiveSet, Lines, LineStrips, MeshedPrimitiveSet, Points, QuadMeshes, Quads, QuadStrips, SkinnedTriangles, StrippedPrimitiveSet, Triangles, TriFans, and TriStrips.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 AnimatedQuads, AnimatedTriangles, and SkinnedTriangles.

virtual NVSG_API nvmath::Sphere3f calculateBoundingSphere ( ) const [protected, virtual]

Calculate the bounding sphere of this PrimitiveSet.

Returns:
The bounding sphere of this PrimitiveSet.
Remarks:
This function is called by the framework to determine the sphere to be used as the bounding sphere. It calculates the sphere around the vertices of the VertexAttributeSet. If there are none, an invalid sphere is returned.
See also:
nvmath::Sphere3f

Implements Drawable.

Reimplemented in IndependentPrimitiveSet, MeshedPrimitiveSet, and StrippedPrimitiveSet.

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 Fri Aug 4 08:38:28 2006 for NVSGSDK by NVIDIA


Member List

PrimitiveSet Member List

This is the complete list of members for PrimitiveSet, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | PrimitiveSet | [protected, virtual]
clone() const=0 | PrimitiveSet | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | PrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:28 2006 for NVSGSDK by NVIDIA


PrimitiveSetCombineTraverser Class Reference

Optimizing Traverser that combines PrimitiveSets under one GeoNode. More...

#include <PrimitiveSetCombineTraverser.h>

Inheritance diagram for PrimitiveSetCombineTraverser:

[legend]
Collaboration diagram for PrimitiveSetCombineTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | PrimitiveSetCombineTraverser (void)
Constructor.

NVSG_API bool | getIgnoreShares (void) const
Get the 'ignore shares' flag.

NVSG_API void | setIgnoreShares (bool ignore)
Set the 'ignore shares' flags.

NVSG_API size_t | getMaxNumberOfVertices () const
Get the maximal number of vertices for combined PrimitiveSet objects.

NVSG_API void | setMaxNumberOfVertices (size_t mnov)
Get the maximal number of vertices for combined PrimitiveSet objects.

Protected Member Functions

virtual NVSG_API | ~PrimitiveSetCombineTraverser (void)
Protected destructor to prevent instantiation of a PrimitiveSetCombineTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
doApply override

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Routine to handle a GeoNode while traversing the scene graph.

virtual NVSG_API void | handleLines (const nvsg::Lines *p)
Routine to handle a Lines while traversing the scene graph.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *p)
Routine to handle a LineStrips while traversing the scene graph.

virtual NVSG_API void | handlePoints (const nvsg::Points *p)
Routine to handle a Points while traversing the scene graph.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *p)
Routine to handle a QuadMeshes while traversing the scene graph.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
Routine to handle a Quads while traversing the scene graph.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Routine to handle a QuadStrips while traversing the scene graph.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
Routine to handle a Triangles while traversing the scene graph.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
Routine to handle a TriFans while traversing the scene graph.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *p)
Routine to handle a TriStrips while traversing the scene graph.

virtual NVSG_API void | handleStateSet (const nvsg::StateSet *p)
Routine to handle a StateSet while traversing the scene graph.

Detailed Description

Optimizing Traverser that combines PrimitiveSets under one GeoNode.

All PrimitiveSets of the same type that are bound to the same StateSet are combined to one Drawable.

Constructor & Destructor Documentation

NVSG_API PrimitiveSetCombineTraverser ( void )

Constructor.

virtual NVSG_API ~PrimitiveSetCombineTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a PrimitiveSetCombineTraverser on stack.

Member Function Documentation

bool getIgnoreShares ( void ) const [inline]

Get the 'ignore shares' flag.

If the 'ignore shares' flag is set, shared PrimitiveSets are also combined. This may result in a larger memory footprint.

Returns:
true if the shares will be ignored, otherwise false

void setIgnoreShares ( bool ignore ) [inline]

Set the 'ignore shares' flags.

If the 'ignore shares' flag is set, shared PrimitiveSets are also combined. This may result in a larger memory footprint. The default is to not ignore shares.

Parameters:
ignore set true to ignore shares on combining

size_t getMaxNumberOfVertices ( ) const [inline]

Get the maximal number of vertices for combined PrimitiveSet objects.

If two combinable PrimitiveSet objects together would have more than this maximal number of vertices, they are not combined.

Returns:
The maximal number of vertices for combined PrimitiveSet objects.

void setMaxNumberOfVertices ( size_t mnov ) [inline]

Get the maximal number of vertices for combined PrimitiveSet objects.

If two combinable PrimitiveSet objects together would have more than this maximal number of vertices, they are not combined.

virtual NVSG_API void doApply ( const nvsg::Scene * scene ) [protected, virtual]

doApply override

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode while traversing the scene graph.

After traversing, drawables of the same type bound to the same StateSet are combined.

Parameters:
p Points to the currently visited GeoNode object.

Reimplemented from Traverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Routine to handle a Lines while traversing the scene graph.

Just gathers lines for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited Lines object.

Reimplemented from Traverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Routine to handle a LineStrips while traversing the scene graph.

Just gathers line strips for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited LineStrips object.

Reimplemented from Traverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Routine to handle a Points while traversing the scene graph.

Just gathers points for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited Points object.

Reimplemented from Traverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Routine to handle a QuadMeshes while traversing the scene graph.

Just gathers quad strips for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited QuadMeshes object.

Reimplemented from Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Routine to handle a Quads while traversing the scene graph.

Just gathers quads for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited Quads object.

Reimplemented from Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Routine to handle a QuadStrips while traversing the scene graph.

Just gathers quad strips for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited QuadStrips object.

Reimplemented from Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Routine to handle a Triangles while traversing the scene graph.

Just gathers triangles for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited Triangles object.

Reimplemented from Traverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Routine to handle a TriFans while traversing the scene graph.

Just gathers triangle fans for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited TriFans object.

Reimplemented from Traverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Routine to handle a TriStrips while traversing the scene graph.

Just gathers triangle strips for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited TriStrips object.

Reimplemented from Traverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Routine to handle a StateSet while traversing the scene graph.

Hold the active StateSet for the next PrimitiveSet for combining (done in handleGeoNode).

Parameters:
p Points to the currently visited StateSet object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • PrimitiveSetCombineTraverser.h
Generated on Fri Aug 4 08:39:29 2006 for NVSGSDK by NVIDIA


Member List

PrimitiveSetCombineTraverser Member List

This is the complete list of members for PrimitiveSetCombineTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | PrimitiveSetCombineTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getIgnoreShares(void) const | PrimitiveSetCombineTraverser | [inline]
getMaxNumberOfVertices() const | PrimitiveSetCombineTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | PrimitiveSetCombineTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
PrimitiveSetCombineTraverser(void) | PrimitiveSetCombineTraverser |
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]
setIgnoreShares(bool ignore) | PrimitiveSetCombineTraverser | [inline]
setMaxNumberOfVertices(size_t mnov) | PrimitiveSetCombineTraverser | [inline]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~PrimitiveSetCombineTraverser(void) | PrimitiveSetCombineTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:29 2006 for NVSGSDK by NVIDIA


PrimitiveSetUnifyTraverser Class Reference

Optimzing Traverser that unifies PrimitiveSets. More...

#include <PrimitiveSetUnifyTraverser.h>

Inheritance diagram for PrimitiveSetUnifyTraverser:

[legend]
Collaboration diagram for PrimitiveSetUnifyTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | PrimitiveSetUnifyTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~PrimitiveSetUnifyTraverser (void)
Protected destructor to prevent instantiation of a PrimitiveSetUnifyTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *pScene)
clear temporary storage after traversing

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Store the current GeoNode to use in the Drawable handlers.

virtual NVSG_API void | handleLines (const nvsg::Lines *p)
Test if a Lines equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleLineStrips (const nvsg::LineStrips *p)
Test if a LineStrips equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handlePoints (const nvsg::Points *p)
Test if a Points equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleQuadMeshes (const nvsg::QuadMeshes *p)
Test if a QuadMeshes equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
Test if a Quads equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Test if a QuadStrips equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
Test if a Triangles equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
Test if a TriFans equivalent to this has been encountered and replace it by that. */.

virtual NVSG_API void | handleTriStrips (const nvsg::TriStrips *p)
Test if a TriStrips equivalent to this has been encountered and replace it by that. */.

Detailed Description

Optimzing Traverser that unifies PrimitiveSets.

Maps identical PrimitiveSets to the same one.

Constructor & Destructor Documentation

NVSG_API PrimitiveSetUnifyTraverser ( void )

Constructor.

virtual NVSG_API ~PrimitiveSetUnifyTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a PrimitiveSetUnifyTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * pScene ) [protected, virtual]

clear temporary storage after traversing

Parameters:
pScene scene to unify PrimitiveSets in

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Store the current GeoNode to use in the Drawable handlers.

Parameters:
p Points to the currently visited GeoNode object.

Reimplemented from Traverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Test if a Lines equivalent to this has been encountered and replace it by that. */.

Parameters:
p Lines to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Test if a LineStrips equivalent to this has been encountered and replace it by that. */.

Parameters:
p LineStrips to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Test if a Points equivalent to this has been encountered and replace it by that. */.

Parameters:
p Points to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Test if a QuadMeshes equivalent to this has been encountered and replace it by that. */.

Parameters:
p QuadMeshes to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Test if a Quads equivalent to this has been encountered and replace it by that. */.

Parameters:
p Quads to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Test if a QuadStrips equivalent to this has been encountered and replace it by that. */.

Parameters:
p QuadStrips to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Test if a Triangles equivalent to this has been encountered and replace it by that. */.

Parameters:
p Triangles to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Test if a TriFans equivalent to this has been encountered and replace it by that. */.

Parameters:
p TriFans to test for replacement

Reimplemented from Traverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Test if a TriStrips equivalent to this has been encountered and replace it by that. */.

Parameters:
p TriStrips to test for replacement

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • PrimitiveSetUnifyTraverser.h
Generated on Fri Aug 4 08:39:30 2006 for NVSGSDK by NVIDIA


Member List

PrimitiveSetUnifyTraverser Member List

This is the complete list of members for PrimitiveSetUnifyTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *pScene) | PrimitiveSetUnifyTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | PrimitiveSetUnifyTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
PrimitiveSetUnifyTraverser(void) | PrimitiveSetUnifyTraverser |
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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~PrimitiveSetUnifyTraverser(void) | PrimitiveSetUnifyTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:30 2006 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 Fri Aug 4 08:40:14 2006 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 Fri Aug 4 08:40:14 2006 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

virtual NVSG_API const QuadMeshes * | clone () const
Create a new QuadMeshes by copying from this.

NVSG_API QuadMeshes & | operator= (const QuadMeshes &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const QuadMeshes * | create ()
Create a QuadMeshes.

NVSG_API const QuadMeshes * | createFromBase (const MeshedPrimitiveSet &rhs)
Create a QuadMeshes by copying from an MeshedPrimitiveSet.

Protected Member Functions

NVSG_API | QuadMeshes ()
Protected constructor to prevent explicit creation.

NVSG_API | QuadMeshes (const MeshedPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | QuadMeshes (const QuadMeshes &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~QuadMeshes ()
Protected destructor to prevent explicit creation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const QuadMeshes *qm, size_t tu=0, size_t tg=1, size_t bn=2)
Generate tangents and binormals for a QuadMeshes.

NVSG_API void | generateNormals (const 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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside QuadMeshes::create.

NVSG_API QuadMeshes ( const MeshedPrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant MeshedPrimitiveSet to use as a base of the new QuadMeshes
Remarks:
This constructor is never used explicitly, but only inside QuadMeshes::createFromBase.
See also:
MeshedPrimitiveSet

NVSG_API QuadMeshes ( const QuadMeshes & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant QuadMeshes to copy from
Remarks:
This constructor is never used explicitly, but only inside QuadMeshes::create.

virtual NVSG_API ~QuadMeshes ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the QuadMeshes is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const QuadMeshes* create ( ) [static]

Create a QuadMeshes.

Returns:
A pointer to a constant QuadMeshes.
Remarks:
Per default a QuadMeshes is empty.

NVSG_API const QuadMeshes* createFromBase ( const MeshedPrimitiveSet & rhs ) [static]

Create a QuadMeshes by copying from an MeshedPrimitiveSet.

Parameters:
rhs A reference to the constant MeshedPrimitiveSet to copy from
Returns:
A pointer to a constant QuadMeshes.
Remarks:
All the data from the MeshedPrimitiveSet rhs is used as the base information for the newly created QuadMeshes. The indices provided with rhs are interpreted then as series of quad meshes.
See also:
MeshedPrimitiveSet

virtual NVSG_API const QuadMeshes* clone ( ) const [virtual]

Create a new QuadMeshes by copying from this.

Returns:
A pointer to a constant QuadMeshes.
Remarks:
The newly created QuadMeshes is an exact copy of this.

Implements MeshedPrimitiveSet.

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 | ( | const QuadMeshes * | qm,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | 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 ( const 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 Fri Aug 4 08:38:30 2006 for NVSGSDK by NVIDIA


Member List

QuadMeshes Member List

This is the complete list of members for QuadMeshes, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | MeshedPrimitiveSet | [protected, virtual]
calculateTangentSpace(const QuadMeshes *qm, size_t tu=0, size_t tg=1, size_t bn=2) | QuadMeshes | [related]
clone() const | QuadMeshes | [virtual]
create() | QuadMeshes | [static]
createFromBase(const MeshedPrimitiveSet &rhs) | QuadMeshes | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const QuadMeshes *qm) | QuadMeshes | [related]
getBoundingSphere(void) const | Drawable |
getDataID() const | MeshedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getMeshes() const | MeshedPrimitiveSet | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfMeshes() const | MeshedPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasMeshes() const | MeshedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | MeshedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | MeshedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
MeshedPrimitiveSet() | MeshedPrimitiveSet | [protected]
MeshedPrimitiveSet(const MeshedPrimitiveSet &rhs) | MeshedPrimitiveSet | [protected]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
QuadMeshes() | QuadMeshes | [protected]
QuadMeshes(const MeshedPrimitiveSet &rhs) | QuadMeshes | [protected]
QuadMeshes(const QuadMeshes &rhs) | QuadMeshes | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setMeshes(const IndexMesh *meshes, size_t numMeshes) | MeshedPrimitiveSet |
setMeshes(size_t pos, const IndexMesh *meshes, size_t numMeshes) | MeshedPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~MeshedPrimitiveSet() | MeshedPrimitiveSet | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~QuadMeshes() | QuadMeshes | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:30 2006 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

virtual NVSG_API const Quads * | clone () const
Create a new Quads by copying from this.

NVSG_API bool | hasFaces () const
Query if this Quads has faces.

NVSG_API size_t | 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, size_t numFaces)
Set the faces of this Quads.

NVSG_API void | setFaces (size_t pos, const Face4 *faces, size_t numFaces)
Set a subset of faces of this Quads.

NVSG_API Quads & | operator= (const Quads &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const Quads * | create ()
Create a Quads.

NVSG_API const Quads * | createFromBase (const IndependentPrimitiveSet &rhs)
Create a Quads by copying from an IndependentPrimitiveSet.

NVSG_API const Quads * | createFromBase (const PrimitiveSet &rhs)
Create a Quads by copying from a PrimitiveSet.

Protected Member Functions

NVSG_API | Quads ()
Protected constructor to prevent explicit creation.

NVSG_API | Quads (const IndependentPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Quads (const PrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Quads (const Quads &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Quads ()
Protected destructor to prevent explicit creation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const Quads *q, size_t tu=0, size_t tg=1, size_t bn=2)
Generate tangents and binormals for a Quads.

NVSG_API void | generateNormals (const 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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Quads::create.

NVSG_API Quads ( const IndependentPrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to use as a base of the new Quads
Remarks:
This constructor is never used explicitly, but only inside Quads::createFromBase.
See also:
IndependentPrimitiveSet

NVSG_API Quads ( const PrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveSet to use as a base of the new Quads
Remarks:
This constructor is never used explicitly, but only inside Quads::createFromBase.
See also:
PrimitiveSet

NVSG_API Quads ( const Quads & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Quads to copy from
Remarks:
This constructor is never used explicitly, but only inside Quads::create.

virtual NVSG_API ~Quads ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Quads is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Quads* create ( ) [static]

Create a Quads.

Returns:
A pointer to a constant Quads.
Remarks:
Per default a Quads is empty.

NVSG_API const Quads* createFromBase ( const IndependentPrimitiveSet & rhs ) [static]

Create a Quads by copying from an IndependentPrimitiveSet.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to copy from
Returns:
A pointer to a constant Quads.
Remarks:
All the data from the IndependentPrimitiveSet rhs is used as the base information for the newly created Quads. The indices provided with rhs are then interpreted as quadruples defining quads.
See also:
IndependentPrimitiveSet

NVSG_API const Quads* createFromBase ( const PrimitiveSet & rhs ) [static]

Create a Quads by copying from a PrimitiveSet.

Parameters:
rhs A reference to the constant PrimitiveSet to copy from
Returns:
A pointer to a constant Quads.
Remarks:
All the data from the PrimitiveSet rhs is used as the base information for the newly created Quads. However, there are no indices provided, so there are no quads in the new Quads object.
See also:
IndependentPrimitiveSet

virtual NVSG_API const Quads* clone ( ) const [virtual]

Create a new Quads by copying from this.

Returns:
A pointer to a constant Quads.
Remarks:
The newly created Quads is an exact copy of this.

Implements IndependentPrimitiveSet.

Reimplemented in AnimatedQuads.

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

size_t 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,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const Face4 * | faces,
 |  | size_t | 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 | ( | const Quads * | q,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | 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 ( const 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 Fri Aug 4 08:38:31 2006 for NVSGSDK by NVIDIA


Member List

Quads Member List

This is the complete list of members for Quads, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(const Quads *q, size_t tu=0, size_t tg=1, size_t bn=2) | Quads | [related]
clone() const | Quads | [virtual]
create() | Quads | [static]
createFromBase(const IndependentPrimitiveSet &rhs) | Quads | [static]
createFromBase(const PrimitiveSet &rhs) | Quads | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const Quads *q) | Quads | [related]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFaces() const | Quads | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFaces() const | Quads | [inline]
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Quads | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
Quads() | Quads | [protected]
Quads(const IndependentPrimitiveSet &rhs) | Quads | [protected]
Quads(const PrimitiveSet &rhs) | Quads | [protected]
Quads(const Quads &rhs) | Quads | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setFaces(const Face4 *faces, size_t numFaces) | Quads | [inline]
setFaces(size_t pos, const Face4 *faces, size_t numFaces) | Quads | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~Quads() | Quads | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
Generated on Fri Aug 4 08:38:31 2006 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

virtual NVSG_API const QuadStrips * | clone () const
Create a new QuadStrips by copying from this.

NVSG_API QuadStrips & | operator= (const QuadStrips &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const QuadStrips * | create ()
Create a QuadStrips.

NVSG_API const QuadStrips * | createFromBase (const StrippedPrimitiveSet &rhs)
Create a QuadStrips by copying from an StrippedPrimitiveSet.

Protected Member Functions

NVSG_API | QuadStrips ()
Protected constructor to prevent explicit creation.

NVSG_API | QuadStrips (const StrippedPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | QuadStrips (const QuadStrips &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~QuadStrips ()
Protected destructor to prevent explicit creation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const QuadStrips *qs, size_t tu=0, size_t tg=1, size_t bn=2)
Generate tangents and binormals for a QuadStrips.

NVSG_API void | generateNormals (const 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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside QuadStrips::create.

NVSG_API QuadStrips ( const StrippedPrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to use as a base of the new QuadStrips
Remarks:
This constructor is never used explicitly, but only inside QuadStrips::createFromBase.
See also:
StrippedPrimitiveSet

NVSG_API QuadStrips ( const QuadStrips & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant QuadStrips to copy from
Remarks:
This constructor is never used explicitly, but only inside QuadStrips::create.

virtual NVSG_API ~QuadStrips ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the QuadStrips is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const QuadStrips* create ( ) [static]

Create a QuadStrips.

Returns:
A pointer to a constant QuadStrips.
Remarks:
By default, a QuadStrips is empty.

NVSG_API const QuadStrips* createFromBase ( const StrippedPrimitiveSet & rhs ) [static]

Create a QuadStrips by copying from an StrippedPrimitiveSet.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to copy from
Returns:
A pointer to a constant QuadStrips.
Remarks:
All the data from the StrippedPrimitiveSet rhs is used as the base information for the newly created QuadStrips. The indices provided with rhs are then interpreted as a series of quad strips.
See also:
StrippedPrimitiveSet

virtual NVSG_API const QuadStrips* clone ( ) const [virtual]

Create a new QuadStrips by copying from this.

Returns:
A pointer to a constant QuadStrips.
Remarks:
The newly created QuadStrips is an exact copy of this.

Implements StrippedPrimitiveSet.

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 | ( | const QuadStrips * | qs,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | bn = 2
 | ) | [related]

Generate tangents and binormals for a QuadStrips.

Parameters:
qs | A pointer to the constant QuadStrips to create tangents and binormals for.
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 ( const QuadStrips * q ) [related]

Generate normals for a QuadStrips.

Parameters:
q A pointer to the constant QuadStrips to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • QuadStrips.h
Generated on Fri Aug 4 08:38:32 2006 for NVSGSDK by NVIDIA


Member List

QuadStrips Member List

This is the complete list of members for QuadStrips, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere(void) const | StrippedPrimitiveSet | [protected, virtual]
calculateTangentSpace(const QuadStrips *qs, size_t tu=0, size_t tg=1, size_t bn=2) | QuadStrips | [related]
clone() const | QuadStrips | [virtual]
create() | QuadStrips | [static]
createFromBase(const StrippedPrimitiveSet &rhs) | QuadStrips | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const QuadStrips *q) | QuadStrips | [related]
getBoundingSphere(void) const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
QuadStrips() | QuadStrips | [protected]
QuadStrips(const StrippedPrimitiveSet &rhs) | QuadStrips | [protected]
QuadStrips(const QuadStrips &rhs) | QuadStrips | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setStrips(const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setStrips(size_t pos, const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~QuadStrips() | QuadStrips | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected, virtual]
Generated on Fri Aug 4 08:38:32 2006 for NVSGSDK by NVIDIA


Quatf Class Reference

Quaternion class. More...

#include <Quatf.h>

List of all members.

Public Member Functions

NVSG_API | Quatf (void)
Default constructor.

NVSG_API | Quatf (const Vec4f &v)
Constructor using a Vec4f.

NVSG_API | Quatf (float x, float y, float z, float w)
Constructor using four floats.

NVSG_API | Quatf (const Vec3f &axis, float angle)
Constructor using an axis and an angle.

NVSG_API | Quatf (const Vec3f &vec0, const Vec3f &vec1)
Constructor by two vectors.

NVSG_API | Quatf (const Mat33f &rot)
Constructor by a rotation matrix.

NVSG_API float & | operator[] (size_t i)
Non-constant subscript operator.

NVSG_API const float & | operator[] (size_t i) const
Constant subscript operator.

NVSG_API Quatf & | operator= (const Quatf &q)
Assignment operator.

NVSG_API bool | operator== (const Quatf &q) const
Equality operator.

NVSG_API bool | operator!= (const Quatf &q) const
Inequality operator.

NVSG_API const Quatf | operator- (void) const
Negation operator.

NVSG_API Quatf & | operator *= (const Quatf &q)
Quaternion multiplication with a quaternion (i.e. concatenation) and assignment operator.

NVSG_API const Quatf | operator * (const Quatf &q) const
Quaternion multiplication with a quaternion (i.e. concatenation) operator.

NVSG_API const Vec3f | operator * (const Vec3f &v) const
Quaternion multiplication with a Vec3f.

NVSG_API Quatf & | operator/= (const Quatf &q)
Quaternion division by a quaternion and assignment operator.

NVSG_API const Quatf | operator/ (const Quatf &q) const
Quaternion division by a quaternion operator.

NVSG_API const Quatf | operator~ (void) const
Quaternion conjugation operator.

NVSG_API Quatf & | normalize (void)
Normalize the quaternion.

Related Functions

(Note that these are not member functions.)

void | decompose (const Quatf &q, Vec3f &axis, float &angle)
float | distance (const Quatf &q0, const Quatf &q1)
float | magnitude (const Quatf &q)
bool | isNormalized (const Quatf &q, float epsilon=FLT_EPSILON)
bool | isNull (const Quatf &q, float epsilon=FLT_EPSILON)
template<> NVSG_API Quatf | lerp (float alpha, const Quatf &q0, const Quatf &q1)

Detailed Description

Quaternion class.

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.

Note:
Only unit quaternions represent a rotation.

Constructor & Destructor Documentation

Quatf ( void ) [inline]

Default constructor.

For performance reasons no initialization is performed.

Quatf ( const Vec4f & v ) [inline]

Constructor using a Vec4f.

The four values of v are just copied over to the quaternion. It is assumed that this operation gives a normalized quaternion.

Parameters:
v vector to construct from

Quatf | ( | float | x,
 |  | float | y,
 |  | float | z,
 |  | float | w
 | ) | [inline]

Constructor using four floats.

The four values x, y, z, and w are used for the quaternion. It is assumed that this operation gives a normalized 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 Vec3f and an angle.

NVSG_API Quatf | ( | const Vec3f & | axis,
 |  | float | angle
 | ) |

Constructor using an axis and an angle.

The resulting quaternion represents a rotation by angle radians around axis.

Parameters:
axis | axis to use for quaternion
angle | rotation angle in radians

NVSG_API Quatf | ( | const Vec3f & | vec0,
 |  | const Vec3f & | vec1
 | ) |

Constructor by two vectors.

The resulting quaternion represents the rotation that maps vec0 to vec1.

Parameters:
vec0 | start vector
vec1 | end vector

NVSG_API Quatf ( const Mat33f & rot )

Constructor by a rotation matrix.

The resulting quaternion represents the same rotation as the matrix.

Parameters:
rot rotation matrix

Member Function Documentation

float & operator[] ( size_t i ) [inline]

Non-constant subscript operator.

Returns:
reference to i th element of the quaternion
Parameters:
i index to element to use (i=0,1,2,3)

const float & operator[] ( size_t i ) const [inline]

Constant subscript operator.

Returns:
constant reference to i th element of the quaternion
Parameters:
i index to element to use (i=0,1,2,3)

Quatf & operator= ( const Quatf & q ) [inline]

Assignment operator.

Returns:
reference to the assigned quaternion
Parameters:
q quaternion to copy

bool operator== ( const Quatf & q ) const [inline]

Equality operator.

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.

Returns:
true if the quaternion is equal to q, otherwise false
Parameters:
q quaternion to compare with

bool operator!= ( const Quatf & q ) const [inline]

Inequality operator.

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.

Returns:
true if the quaternion is not equal to q, otherwise false
Parameters:
q quaternion to compare

const Quatf operator- ( void ) const [inline]

Negation operator.

The negation of a quaternion is a rotation around the same axis by the negated angle.

Returns:
negated quaternion

Quatf & operator *= ( const Quatf & q ) [inline]

Quaternion multiplication with a quaternion (i.e. concatenation) and assignment operator.

Multiplying two quaternions give a quaternion that represents the concatenation of the rotations represented by the two quaternions.

Returns:
reference to the assigned quaternion after multiplication (concatenation)
Parameters:
q quaternion to use in the multiplication

const Quatf operator * ( const Quatf & q ) const [inline]

Quaternion multiplication with a quaternion (i.e. concatenation) operator.

Multiplying two quaternions give a quaternion that represents the concatenation of the rotations represented by the two quaternions.

Returns:
multiplied (concatenated) quaternion
Parameters:
q quaternion to multiply with

const Vec3f operator * ( const Vec3f & v ) const [inline]

Quaternion multiplication with a Vec3f.

Multiplying a quaternion with a Vec3f v applies the rotation to v.

Returns:
v rotated by the quaternions rotation.
Parameters:
v vector to rotate

Quatf & operator/= ( const Quatf & q ) [inline]

Quaternion division by a quaternion and assignment operator.

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.

Returns:
reference to the assigned quaternion after division
Parameters:
q quaternion to divide by

const Quatf operator/ ( const Quatf & q ) const [inline]

Quaternion division by a quaternion operator.

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.

Returns:
divided quaternion
Parameters:
q quaternion to divide by

const Quatf operator~ ( void ) const [inline]

Quaternion conjugation operator.

The conjugation of a quaternion is a rotation of the same angle around the negated axis.

Returns:
conjugated quaternion

NVSG_API Quatf& normalize ( void )

Normalize the quaternion.

Note:
We always assume a quaternion to be 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.
Returns:
a reference to the normalized quaternion.

Friends And Related Function Documentation

void decompose | ( | const Quatf & | q,
 |  | Vec3f & | axis,
 |  | float & | angle
 | ) | [related]

Decompose a quaternion into axis and angle.
The quaternion q represents the rotation by angle radians around axis.

Parameters:
q | Quaternion to decompose
axis | Resulting axis
angle | Resulting angle (in radians)

float distance | ( | const Quatf & | q0,
 |  | const Quatf & | q1
 | ) | [related]

Determine the distance between two quaternions.

Returns:
The distance between q0 and q1

float magnitude ( const Quatf & q ) [related]

Calculate the magnitude of a quaternion.
The magnitude of a normalized quaternion is one.

Returns:
magnitude of the quaternion
Parameters:
q Quaternion to determine magnitude of

bool isNormalized | ( | const Quatf & | q,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a quaternion is normalized.
A quaternion is considered to be normalized, when it's magnitude differs less than epsilon from one.

Returns:
true if the quaternion is normalized, otherwise false
Parameters:
q | Quaternion to test
epsilon | optional epsilon

bool isNull | ( | const Quatf & | q,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a quaternion is null.
A quaternion is considered to be null, if it's magnitude is less than epsilon.

Returns:
true if the quaternion is null, otherwise false
Parameters:
q | Quaternion to test
epsilon | optional epsilon

NVSG_API Quatf lerp< Quatf > | ( | float | alpha,
 |  | const Quatf & | q0,
 |  | const Quatf & | q1
 | ) | [related]

Spherical linear interpolation between two quaternions q0 and q1.
This calculates the spherical linear interpolation analog to

 ( 1 - alpha ) * q0 + alpha * q1
Parameters:
alpha | interpolation parameter
q0 | starting value
q1 | ending value

The documentation for this class was generated from the following file:
  • Quatf.h
Generated on Fri Aug 4 08:37:22 2006 for NVSGSDK by NVIDIA


Member List

Quatf Member List

This is the complete list of members for Quatf, including all inherited members.
decompose(const Quatf &q, Vec3f &axis, float &angle) | Quatf | [related]
distance(const Quatf &q0, const Quatf &q1) | Quatf | [related]
isNormalized(const Quatf &q, float epsilon=FLT_EPSILON) | Quatf | [related]
isNull(const Quatf &q, float epsilon=FLT_EPSILON) | Quatf | [related]
lerp(float alpha, const Quatf &q0, const Quatf &q1) | Quatf | [related]
magnitude(const Quatf &q) | Quatf | [related]
normalize(void) | Quatf |
operator *(const Quatf &q) const | Quatf | [inline]
operator *(const Vec3f &v) const | Quatf | [inline]
operator *=(const Quatf &q) | Quatf | [inline]
operator!=(const Quatf &q) const | Quatf | [inline]
operator-(void) const | Quatf | [inline]
operator/(const Quatf &q) const | Quatf | [inline]
operator/=(const Quatf &q) | Quatf | [inline]
operator=(const Quatf &q) | Quatf | [inline]
operator==(const Quatf &q) const | Quatf | [inline]
operator[](size_t i) | Quatf | [inline]
operator[](size_t i) const | Quatf | [inline]
operator~(void) const | Quatf | [inline]
Quatf(void) | Quatf | [inline]
Quatf(const Vec4f &v) | Quatf | [inline]
Quatf(float x, float y, float z, float w) | Quatf | [inline]
Quatf(const Vec3f &axis, float angle) | Quatf |
Quatf(const Vec3f &vec0, const Vec3f &vec1) | Quatf |
Quatf(const Mat33f &rot) | Quatf |
Generated on Fri Aug 4 08:37:23 2006 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 size_t | getNumberOfIntersections (void) const
Get number of intersections.

NVSG_API void | setViewportSize (size_t width, size_t 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 (const nvsg::Scene *scene)
Apply the traverser to the scene.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Routine to handle a GeoNode while traversing the scene graph.

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 *p)
Routine to handle a Group 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)
Provide special treatment of a Transform node.

virtual NVSG_API void | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Routine to handle a AnimatedQuads object while traversing the scene graph.

virtual NVSG_API void | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Routine to handle a AnimatedTriangles object 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 | handleSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Routine to handle a SkinnedTriangles 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 | 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 | handleFaceAttribute (const nvsg::FaceAttribute *p)
Routine to handle a FaceAttribute 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 | handleStateSet (const nvsg::StateSet *p)
Routine to handle a StateSet object while traversing the scene graph.

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 | RayIntersectTraverser::getWorldIntersection (nvmath::Vec3f &isp, float &dist)
Get the intersection point in world coordinates.

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::PrimitiveSet *p, const nvmath::Vec3f &isp, float dist, size_t 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.

size_t getNumberOfIntersections ( void ) const [inline]

Get number of intersections.

Returns:
The number of intersections along the ray.

NVSG_API void setViewportSize | ( | size_t | width,
 |  | size_t | 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 ( const nvsg::Scene * scene ) [protected, virtual]

Apply the traverser to the scene.

Start the intersection calculation of the given ray with the scene objects.

Parameters:
scene Scene to intersect the ray with

Reimplemented from Traverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode while traversing the scene graph.

This routine gets called for each GeoNode object that will be visited while traversing the scene graph. The currently visited GeoNode object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

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 ModelViewTraverser.

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 ModelViewTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Routine to handle a Group node while traversing the scene graph.

This routine gets called for each Group object that will be visited while traversing the scene graph. The currently visited Group object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

During child traversal you must not change the number or the position of children. Overload and use postTraverseGroup() for this.

Reimplemented from Traverser.

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.

This routine gets called for each LOD object that will be visited while traversing the scene graph. The currently visited LOD object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from ModelViewTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Routine to handle a Switch node while traversing the scene graph.

This routine gets called for each Switch object that will be visited while traversing the scene graph. The currently visited Switch object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

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 ModelViewTraverser.

virtual NVSG_API void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Routine to handle a AnimatedQuads object while traversing the scene graph.

This routine gets called for each AnimatedQuads object that will be visited while traversing the scene graph. The currently visited AnimatedQuads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Routine to handle a AnimatedTriangles object while traversing the scene graph.

This routine gets called for each AnimatedTriangles object that will be visited while traversing the scene graph. The currently visited AnimatedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Routine to handle a Lines object while traversing the scene graph.

This routine gets called for each Lines object that will be visited while traversing the scene graph. The currently visited Lines object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Routine to handle a LineStrips object while traversing the scene graph.

This routine gets called for each LineStrips object that will be visited while traversing the scene graph. The currently visited LineStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Routine to handle a Points object while traversing the scene graph.

This routine gets called for each Points object that will be visited while traversing the scene graph. The currently visited Points object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Routine to handle a QuadMeshes object while traversing the scene graph.

This routine gets called for each QuadMeshes object that will be visited while traversing the scene graph. The currently visited QuadMeshes object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Routine to handle a Quads object while traversing the scene graph.

This routine gets called for each Quads object that will be visited while traversing the scene graph. The currently visited Quads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Routine to handle a QuadStrips object while traversing the scene graph.

This routine gets called for each QuadStrips object that will be visited while traversing the scene graph. The currently visited QuadStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Routine to handle a SkinnedTriangles object while traversing the scene graph.

This routine gets called for each SkinnedTriangles object that will be visited while traversing the scene graph. The currently visited SkinnedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Routine to handle a Triangles object while traversing the scene graph.

This routine gets called for each Triangles object that will be visited while traversing the scene graph. The currently visited Triangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Routine to handle a TriFans object while traversing the scene graph.

This routine gets called for each TriFans object that will be visited while traversing the scene graph. The currently visited TriFans object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Routine to handle a TriStrips object while traversing the scene graph.

This routine gets called for each TriStrips object that will be visited while traversing the scene graph. The currently visited TriStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Routine to handle a FaceAttribute attribute while traversing the scene graph.

This routine gets called for each FaceAttribute object that will be visited while traversing the scene graph. The currently visited FaceAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Routine to handle a CgFx attribute while traversing the scene graph.

This routine gets called for each CgFx object that will be visited while traversing the scene graph. The currently visited CgFx object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Routine to handle a StateSet object while traversing the scene graph.

This routine gets called for each StateSet object that will be visited while traversing the scene graph. The currently visited StateSet object is pointed to by p. The base implementation ensures that the currently active StateVariant will be traversed. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

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 ModelViewTraverser.

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 ModelViewTraverser.

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 RayIntersectTraverser::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 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::PrimitiveSet * | p,
 |  | const nvmath::Vec3f & | isp,
 |  | float | dist,
 |  | size_t | 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 | PrimitiveSet 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 Fri Aug 4 08:39:33 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
checkClipPlanes(const nvmath::Vec3f &p) | RayIntersectTraverser | [protected]
checkClipPlanes(const nvmath::Sphere3f &p) | RayIntersectTraverser | [protected]
checkIntersection(const nvmath::Sphere3f &sphere) | RayIntersectTraverser | [protected]
doApply(const nvsg::Scene *scene) | RayIntersectTraverser | [protected, virtual]
dumpIntersectionList() | RayIntersectTraverser | [protected]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIntersections(void) const | RayIntersectTraverser | [inline]
getNearest(void) const | RayIntersectTraverser | [inline]
getNumberOfIntersections(void) const | RayIntersectTraverser | [inline]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | RayIntersectTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | RayIntersectTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | RayIntersectTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RayIntersectTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | RayIntersectTraverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | RayIntersectTraverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | RayIntersectTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | RayIntersectTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | RayIntersectTraverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | RayIntersectTraverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | RayIntersectTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | RayIntersectTraverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | RayIntersectTraverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | RayIntersectTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | RayIntersectTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | RayIntersectTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | RayIntersectTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | RayIntersectTraverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | RayIntersectTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | RayIntersectTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | RayIntersectTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | RayIntersectTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
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]
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RayIntersectTraverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RayIntersectTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RayIntersectTraverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | ModelViewTraverser | [protected, virtual]
preTraverseTransform(const nvmath::Trafo *p) | RayIntersectTraverser | [protected, virtual]
RayIntersectTraverser(void) | RayIntersectTraverser |
RayIntersectTraverser::getWorldIntersection(nvmath::Vec3f &isp, float &dist) | RayIntersectTraverser | [protected]
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 |
setViewportSize(size_t width, size_t height) | RayIntersectTraverser |
setViewState(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
storeIntersection(const nvsg::PrimitiveSet *p, const nvmath::Vec3f &isp, float dist, size_t primitiveIndex, const std::vector< unsigned int > &vertexIndices) | RayIntersectTraverser | [protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RayIntersectTraverser(void) | RayIntersectTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:33 2006 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 Fri Aug 4 08:40:17 2006 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 Fri Aug 4 08:40:17 2006 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 Fri Aug 4 08:40:15 2006 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, 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 Fri Aug 4 08:40:15 2006 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 Fri Aug 4 08:40:18 2006 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 Fri Aug 4 08:40:18 2006 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 Fri Aug 4 08:40:17 2006 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 Fri Aug 4 08:40:17 2006 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 (size_t 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 ( size_t 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 Fri Aug 4 08:40:16 2006 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, 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(size_t 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 Fri Aug 4 08:40:16 2006 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 Fri Aug 4 08:40:19 2006 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 Fri Aug 4 08:40:19 2006 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 Fri Aug 4 08:40:18 2006 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 Fri Aug 4 08:40:18 2006 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 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 (size_t width, size_t height)
Handle the viewport resizing.

NVSG_API size_t | getViewportHeight () const
Get viewport height.

NVSG_API size_t | getViewportWidth () const
Get viewport width.

NVSG_API bool | pickCameraTargetPoint (int x, int y)
Pick the cameras' target point.

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 size_t | getNumberOfCullTraverser () const
Get the number of culling stages in the culling pipeline.

NVSG_API nvtraverser::CullTraverser * | getCullTraverser (size_t 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 (const nvsg::Scene *scene, const nvsg::ViewState *viewState)
Register the Scene and the nvsg::ViewState with this RenderArea.

NVSG_API const nvsg::ViewState * | getViewState () const
Get the current nvsg::ViewState.

NVSG_API void | setViewState (const nvsg::ViewState *viewState)
Register a nvsg::ViewState.

NVSG_API const nvsg::Scene * | getScene () const
Get the current nvsg::Scene.

NVSG_API void | setScene (const nvsg::Scene *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 size_t | createNewRenderAreaID ()
Create a unique ID for a RenderArea.

Protected Types

enum | { _UNDEFINED = 0x00000000, _STEREO = 0x00000001, _MULTISAMPLE = 0x00000002 }
Possible features of the RenderArea. (mainly influencing the pixel format - OpenGL). More...

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.

const nvsg::Scene * | m_scene
Pointer to the scene.

const nvsg::ViewState * | m_viewState
Pointer to the view specific controls (camera, animation state,...).

unsigned long | 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.

size_t | m_raHeight
Height of the render area.

size_t | 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

size_t | 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 [protected]

Possible features of the RenderArea. (mainly influencing the pixel format - OpenGL).

Enumeration values:
_UNDEFINED | No special feature requested.
_STEREO | Stereo requested.
_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 | ( | size_t | width,
 |  | size_t | 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.

size_t getViewportHeight ( ) const [inline]

Get viewport height.

Returns:
The height of the viewport in pixels.
See also:
getViewportWidth

size_t getViewportWidth ( ) const [inline]

Get viewport width.

Returns:
The width of the viewport in pixels.
See also:
getViewportHeight

NVSG_API bool pickCameraTargetPoint | ( | int | x,
 |  | int | y
 | ) |

Pick the cameras' target point.

Parameters:
x | Current x position of the mouse.
y | Current x position of the mouse.
Returns:
false - no intersection.
Remarks:
Determine the target point and report it to the current camera. This function takes the mouse coordinates and sends a ray into the scene to calculate the nearest intersection with an object from the scene. It then takes the intersection and and makes the camera look at this point. The distance between the camera and the intersection point is calculated and reported to the nvsg::ViewState (nvsg::ViewState::setTargetDistance).
This information allows e.g. the nvui::Manipulator to calculate the rotation point.
See also:
nvsg::ViewState::setTargetDistance, nvsg::Camera::setDirection, nvtraverser::RayIntersectTraverser

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

size_t 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 ( size_t 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 | ( | const nvsg::Scene * | scene,
 |  | const nvsg::ViewState * | viewState
 | ) |

Register the Scene and the nvsg::ViewState with this RenderArea.

Parameters:
scene | nvsg::Scene to replace the RenderArea's current nvsg::Scene. Passing in NULL leads to undefined behavior.
viewState | nvsg::ViewState to replace the RenderArea's current nvsg::ViewState. Passing in NULL leads to undefined behavior.
Remarks:
The function replaces the RenderArea's current nvsg::Scene and nvsg::ViewState. The reference count of the already contained nvsg::Scene and nvsg::ViewState will be decremented where the reference count of the new nvsg::Scene and nvsg::ViewState will be incremented.
See also:
setViewState, getViewState, setScene, getScene

const nvsg::ViewState * getViewState ( ) const [inline]

Get the current nvsg::ViewState.

Returns:
Pointer to the nvsg::ViewState. If no nvsg::ViewState was registered prior to this call the result will be NULL;
Remarks:
Get the currently registered nvsg::ViewState of the nvsg::RenderArea.
See also:
setViewState, setSceneData

NVSG_API void setViewState ( const nvsg::ViewState * viewState )

Register a nvsg::ViewState.

Parameters:
viewState nvsg::ViewState to replace the RenderArea's current nvsg::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

const nvsg::Scene * getScene ( ) const [inline]

Get the current nvsg::Scene.

Returns:
Pointer to 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

NVSG_API void setScene ( const nvsg::Scene * scene )

Register a nvsg::Scene.

Parameters:
scene nvsg::Scene to replace the RenderArea's current nvsg::Scene. Passing in NULL as the new nvsg::Scene 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

size_t 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.

const nvsg::Scene* m_scene [protected]

Pointer to the scene.

m_scene could be NULL !!

const nvsg::ViewState* m_viewState [protected]

Pointer to the view specific controls (camera, animation state,...).

unsigned long 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.

size_t m_raHeight [protected]

Height of the render area.

size_t m_raWidth [protected]

Width of the render area.

size_t 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 Fri Aug 4 08:40:00 2006 for NVSGSDK by NVIDIA


Member List

RenderArea Member List

This is the complete list of members for RenderArea, including all inherited members.
_MULTISAMPLE enum value | RenderArea | [protected]
_STEREO enum value | RenderArea | [protected]
_UNDEFINED enum value | RenderArea | [protected]
createNewRenderAreaID() | RenderArea | [inline, static]
destroy(void) | RenderArea | [virtual]
getAppTraverser() const | RenderArea | [inline]
getAspectRatio() const | RenderArea | [inline]
getCullTraverser(size_t 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]
pickCameraTargetPoint(int x, int y) | 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(const nvsg::Scene *scene) | RenderArea |
setSceneData(const nvsg::Scene *scene, const nvsg::ViewState *viewState) | RenderArea |
setViewportSize(size_t width, size_t height) | RenderArea | [virtual]
setViewState(const nvsg::ViewState *viewState) | RenderArea |
triggerRedraw(void) | RenderArea | [virtual]
wasRenderInterrupted() const | RenderArea | [inline]
~RenderArea() | RenderArea | [virtual]
Generated on Fri Aug 4 08:40:00 2006 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 }
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
}
enum | OITTechnique { OT_TEXTURE, OT_PBUFFER }

Public Member Functions

NVSG_API bool | isCgFxAware (void) const
Get the CgFx-awareness of this RenderTraverser.

NVSG_API GeometryCacheTechnique | getGeometryCacheTechnique (void) const
Get the current geoemtry 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
Test on supported jitter techniques.

virtual NVSG_API void | setJitterTechnique (JitterTechnique jt)
Set the jitter technique the render should 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 | isTwoSidedLigthing () 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 size_t | getShadowMapSize (void) const
Get the size of the shadow maps.

virtual NVSG_API void | setShadowMapSize (size_t 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 size_t | getTextureSizeLimit (void) const
Get the texture size limit.

virtual NVSG_API void | setTextureSizeLimit (size_t 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 size_t | getOITMaxPasses (void) const
Get maximum OIT passes.

virtual NVSG_API void | setOITMaxPasses (size_t 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 (const nvsg::Scene *scene)
Initiate traversing a given scene graph.

virtual NVSG_API void | doRender (const nvsg::Scene *scene)=0
Initiate rendering the prepared scene.

NVSG_API void | setCgFxAwareness (bool aware)
Set the CgFx-awareness of this RenderTraverser.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Traverse a Billboard.

virtual NVSG_API void | handleParallelCamera (const nvsg::ParallelCamera *p, const nvsg::Node *root)
Traverse a ParallelCamera.

virtual NVSG_API void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p, const nvsg::Node *root)
Traverse a PerspectiveCamera.

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 bool | preTraverseDrawables (const nvsg::GeoNode *p, size_t i)
Prepares render list setup for coherent Drawables.

virtual NVSG_API void | postTraverseDrawables (const nvsg::GeoNode *p, size_t 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.

virtual NVSG_API void | handleMapArray (const nvsg::MapArray *p)
handleMapArray override for specialized handling of MapArray.

virtual NVSG_API void | preTraverseMap (const nvsg::MapArray *p, size_t index)
preTraverseMap override for specialized handling of MapArray per Map.

virtual NVSG_API void | handleMapElement (const nvsg::MapElement *p)
handleMapElement override for specialized handling of MapElement.

virtual NVSG_API void | handleMapMatrix (const nvsg::MapMatrix *p)
handleMapMatrix override for specialized handling of MapMatrix.

virtual NVSG_API void | preTraverseMap (const nvsg::MapMatrix *p, size_t col, size_t row)
preTraverseMap override for specialized handling of MapMatrix per Map.

virtual NVSG_API void | preTraverseMapColumn (const nvsg::MapMatrix *p, size_t col)
preTraverseMapColumn override for specialized handling of MapMatrix per column of Maps.

virtual NVSG_API void | postTraverseMapColumn (const nvsg::MapMatrix *p, size_t col)
postTraverseMapColumn override for specialized handling of MapMatrix per column of Maps.

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 (const nvsg::Object *object)
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 (const nvsg::Object *object, T arg)
Start rendering a general object.

virtual NVSG_API void | renderQuadMeshes (const nvsg::QuadMeshes *p)
Render a QuadMeshes out of a render list.

virtual NVSG_API void | renderAnimatedQuads (const nvsg::AnimatedQuads *p)
Render an AnimatedQuads out of a render list.

virtual NVSG_API void | renderAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Render an AnimatedTriangles out of 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 | 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 | 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 | 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, size_t 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 | setClipPlane (size_t 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 const nvsg::CgFx * | 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 void | getMapPosition (size_t &x, size_t &y)
Get the position of the current Map.

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 containes 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.

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.

enum OITTechnique

Enumeration values:
OT_TEXTURE | Use textures for OIT.
OT_PBUFFER | Use PBuffers for OIT.

Constructor & Destructor Documentation

NVSG_API RenderTraverser ( void ) [protected]

Default constructor.

virtual NVSG_API ~RenderTraverser ( void ) [protected, virtual]

Default destructor.

Member Function Documentation

bool isCgFxAware ( void ) const [inline]

Get the CgFx-awareness of this RenderTraverser.

Returns:
true, if this RenderTraverser is CgFx-aware, otherwise false.

RenderTraverser::GeometryCacheTechnique getGeometryCacheTechnique ( void ) const [inline]

Get the current geoemtry 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 technique.

virtual NVSG_API bool isJitterTechniqueSupported ( JitterTechnique jt ) const [virtual]

Test on supported jitter techniques.

Use this method to test if this special jitter technique is currently available.

Returns:
true - supported, false - not supported
Parameters:
jt Jitter technique.

Reimplemented in GLTraverser.

virtual NVSG_API void setJitterTechnique ( JitterTechnique jt ) [virtual]

Set the jitter technique the render should use.

Parameters:
jt Jitter technique

Reimplemented in GLTraverser.

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 isTwoSidedLigthing ( ) 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.

size_t getShadowMapSize ( void ) const [inline]

Get the size of the shadow maps.

Returns:
the size of the shadow maps.

virtual NVSG_API void setShadowMapSize ( size_t 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 inbetween 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 inbetween the darkness (or depth) of the shadows varies linear.

size_t 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 ( size_t 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.

size_t getOITMaxPasses ( void ) const [inline]

Get maximum OIT passes.

Returns:
Maximum rendering passes to archive the desired effect.

virtual NVSG_API void setOITMaxPasses ( size_t 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 thereshold 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 ( const nvsg::Scene * scene ) [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 behaviour is not defined. Call setViewState() with a valid ViewState prior calling apply().
Parameters:
scene Pointer to a valid scene.

Reimplemented from Traverser.

Reimplemented in GLTraverser.

virtual NVSG_API void doRender ( const nvsg::Scene * scene ) [protected, pure virtual]

Initiate rendering the prepared scene.

Implemented in GLTraverser.

void setCgFxAwareness ( bool aware ) [inline, protected]

Set the CgFx-awareness of this RenderTraverser.

If a concrete RenderTraverser decides to be CgFx-aware, it should call this function.

Parameters:
aware set the awareness to aware

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 ModelViewTraverser.

virtual NVSG_API void handleParallelCamera | ( | const nvsg::ParallelCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Traverse a ParallelCamera.

Stores this ParallelCamera as the current and calls ModelViewTraverser::handleParallelCamera for further traversal.

Parameters:
p | ParallelCamera to traverse
root | root node of tree to traverse

Reimplemented from ModelViewTraverser.

virtual NVSG_API void handlePerspectiveCamera | ( | const nvsg::PerspectiveCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Traverse a PerspectiveCamera.

Stores this PerspectiveCamera as the current and calls ModelViewTraverser::handlePerspectiveCamera for further traversal.

Parameters:
p | PerspectiveCamera to traverse
root | root node of tree to traverse

Reimplemented from ModelViewTraverser.

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 Traverser.

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 ModelViewTraverser.

virtual NVSG_API bool preTraverseDrawables | ( | const nvsg::GeoNode * | p,
 |  | size_t | 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,
 |  | size_t | 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 ModelViewTraverser.

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 ModelViewTraverser.

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 Traverser.

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 Traverser.

virtual NVSG_API void handleMapArray ( const nvsg::MapArray * p ) [protected, virtual]

handleMapArray override for specialized handling of MapArray.

Reimplemented from Traverser.

virtual NVSG_API void preTraverseMap | ( | const nvsg::MapArray * | p,
 |  | size_t | index
 | ) | [protected, virtual]

preTraverseMap override for specialized handling of MapArray per Map.

Reimplemented from Traverser.

virtual NVSG_API void handleMapElement ( const nvsg::MapElement * p ) [protected, virtual]

handleMapElement override for specialized handling of MapElement.

Reimplemented from Traverser.

virtual NVSG_API void handleMapMatrix ( const nvsg::MapMatrix * p ) [protected, virtual]

handleMapMatrix override for specialized handling of MapMatrix.

Reimplemented from Traverser.

virtual NVSG_API void preTraverseMap | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col,
 |  | size_t | row
 | ) | [protected, virtual]

preTraverseMap override for specialized handling of MapMatrix per Map.

Reimplemented from Traverser.

virtual NVSG_API void preTraverseMapColumn | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col
 | ) | [protected, virtual]

preTraverseMapColumn override for specialized handling of MapMatrix per column of Maps.

Reimplemented from Traverser.

virtual NVSG_API void postTraverseMapColumn | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col
 | ) | [protected, virtual]

postTraverseMapColumn override for specialized handling of MapMatrix per column of Maps.

Reimplemented from Traverser.

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 ( const nvsg::Object * object ) [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.
Parameters:
obj Points to the object to be rendered.

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 indispensible 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 | ( | const nvsg::Object * | object,
 |  | 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.
Parameters:
obj | Points to the object to be rendered.
arg | Specifies an additional argument that will be passed to the render routine.

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 renderAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Render an AnimatedQuads out of a render list.

This base implementation calls renderQuads().

Parameters:
p AnimatedQuads to render

Reimplemented in GLTraverser.

virtual NVSG_API void renderAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Render an AnimatedTriangles out of a render list.

This base implementation calls renderTriangles().

Parameters:
p AnimatedTriangles to render

Reimplemented in GLTraverser.

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 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 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 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,
 |  | size_t | 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 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 setClipPlane | ( | size_t | 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.

const nvsg::CgFx * 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 behaviour 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 behaviour 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 behaviour 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 behaviour 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.

void getMapPosition | ( | size_t & | x,
 |  | size_t & | y
 | ) | [inline, protected]

Get the position of the current Map.

While traversing the MapList for rendering, the position of the Map to render can be queried with this function. The position is calculated and updated in RenderTraverser::preTraverseMap just before the handler routine for the Map is called. The position is given in raster coordinates and represents the position in the viewport where the lower left corner of the Map is located.

The documentation for this class was generated from the following file:
  • RenderTraverser.h
Generated on Fri Aug 4 08:39:37 2006 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, HandlerType handler) | Traverser | [inline, protected]
addObjectRenderer(unsigned int objectCode, RendererType renderer) | RenderTraverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *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]
beginEdit(const T *obj) const | Traverser | [inline, protected]
beginOcclusionCullQuery(unsigned int id) | RenderTraverser | [protected, virtual]
clearRenderLists(void) | RenderTraverser | [protected]
createOcclusionCullID(void) | RenderTraverser | [protected, virtual]
destroyOcclusionCullID(unsigned int id) | RenderTraverser | [protected, virtual]
doApply(const nvsg::Scene *scene) | RenderTraverser | [protected, virtual]
doRender(const nvsg::Scene *scene)=0 | RenderTraverser | [protected, pure virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
endOcclusionCullQuery(unsigned int id) | RenderTraverser | [protected, virtual]
GCT_DL enum value | RenderTraverser |
GCT_NONE enum value | RenderTraverser |
GCT_VBO enum value | RenderTraverser |
GeometryCacheTechnique enum name | RenderTraverser |
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]
getMapPosition(size_t &x, size_t &y) | RenderTraverser | [inline, protected]
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]
getProblems() | Traverser |
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]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | ModelViewTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | RenderTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | ModelViewTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | RenderTraverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | RenderTraverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | RenderTraverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | RenderTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | RenderTraverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | RenderTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | RenderTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [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]
isCgFxAware(void) const | RenderTraverser | [inline]
isFaceCullingOverwrite() const | RenderTraverser | [inline]
isFaceModeOverwrite() const | RenderTraverser | [inline]
isFrontFaceCulling() const | RenderTraverser | [inline]
isGeometryCacheTechniqueSupported(GeometryCacheTechnique gct) const | RenderTraverser | [virtual]
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]
isTwoSidedLightingOverwrite() const | RenderTraverser | [inline]
isTwoSidedLigthing() const | RenderTraverser | [inline]
JitterTechnique enum name | RenderTraverser |
JT_ACCUM enum value | RenderTraverser |
JT_NONE enum value | RenderTraverser |
JT_PBUFFER enum value | RenderTraverser |
JT_READ_PIXELS enum value | RenderTraverser |
m_cameraPosition (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cameraUpVector (defined in ModelViewTraverser) | ModelViewTraverser | [protected]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_transformStack | ModelViewTraverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
ModelViewTraverser(bool readOnly=true) | ModelViewTraverser | [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, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OT_PBUFFER enum value | RenderTraverser |
OT_TEXTURE enum value | RenderTraverser |
overlayBegin(void) | RenderTraverser | [protected, virtual]
overlayEnd(void) | RenderTraverser | [protected, virtual]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | RenderTraverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | RenderTraverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseTransform(const nvmath::Trafo *p) | RenderTraverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | RenderTraverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | RenderTraverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | RenderTraverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | RenderTraverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | RenderTraverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | ModelViewTraverser | [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]
renderAnimatedQuads(const nvsg::AnimatedQuads *p) | RenderTraverser | [protected, virtual]
renderAnimatedTriangles(const nvsg::AnimatedTriangles *p) | RenderTraverser | [protected, virtual]
renderBegin(void) | 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]
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(const nvsg::Object *object) | RenderTraverser | [inline, protected]
renderObject(const nvsg::Object *object, 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, size_t tu) | 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]
RT_EFFECTED enum value | RenderTraverser |
RT_SHADED enum value | RenderTraverser |
RT_TEXTURED enum value | RenderTraverser |
RT_UNLIT enum value | RenderTraverser |
setCgFxAwareness(bool aware) | RenderTraverser | [inline, protected]
setClipPlane(size_t index, const nvmath::Plane3f &plane, bool enable) | RenderTraverser | [protected, virtual]
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 | [virtual]
setLineAntiAliasing(bool onOff) | RenderTraverser | [inline]
setLineWidth(float width) | RenderTraverser | [inline]
setOcclusionCulling(bool onOff) | RenderTraverser | [virtual]
setOITMaxPasses(size_t 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 |
setShadowMapIntensity(float intensity) | RenderTraverser | [inline]
setShadowMapSize(size_t size) | RenderTraverser | [virtual]
setShadowTechnique(ShadowTechnique st) | RenderTraverser | [virtual]
setSortingPolicy(SortingPolicy sp) | RenderTraverser | [inline]
setTextureSizeLimit(size_t 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(const nvsg::ViewState *viewState) | ModelViewTraverser | [virtual]
ShadowTechnique enum name | RenderTraverser |
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]
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | RenderTraverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | RenderTraverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
TT_BLENDED 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 |
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ModelViewTraverser() | ModelViewTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~RenderTraverser(void) | RenderTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:37 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:38:52 2006 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, 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 Fri Aug 4 08:38:52 2006 for NVSGSDK by NVIDIA


Scene Class Reference

Container class to hold all scene related information. More...

#include <Scene.h>

Inheritance diagram for Scene:

[legend]
Collaboration diagram for Scene:

[legend]
List of all members.

Public Member Functions

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 const nvmath::Vec3f & | getBackColor () const
Get the background color.

NVSG_API void | setBackColor (const nvmath::Vec3f &color)
Set the background color.

NVSG_API size_t | getNumberOfCameras () const
Get the number of predefined Camera objects.

NVSG_API const Camera * | getCamera (size_t index) const
Get a Camera of the Scene.

NVSG_API void | addCamera (const Camera *camera)
Add a Camera to the list of predefined views.

NVSG_API void | removeCamera (size_t index)
Remove a Camera from the Scene.

NVSG_API size_t | getNumberOfCameraAnimations () const
Get the number of camera animations.

NVSG_API const Animation<
nvmath::Trafo > * 		getCameraAnimation (size_t index) const
Get a camera animation of the Scene.

NVSG_API void | addCameraAnimation (const Animation< nvmath::Trafo > *animation)
Add a camera animation.

NVSG_API void | removeCameraAnimation (size_t index)
Remove a camera animation from the Scene.

NVSG_API size_t | getNumberOfFrames () const
Get the number of animation frames.

NVSG_API const Node * | getRootNode () const
Get the root node of the Scene.

NVSG_API void | setRootNode (const Node *root)
Set 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.

Static Public Member Functions

NVSG_API const Scene * | create ()
Create a Scene.

Protected Member Functions

NVSG_API | Scene ()
Protected default constructor to prevent explicit creation.

virtual NVSG_API | ~Scene ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Scene::create.

virtual NVSG_API ~Scene ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Scene is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Scene* create ( ) [static]

Create a Scene.

Returns:
A pointer to a constant Scene.
Remarks:
By default, the ambient color of a scene is light grey (0.2,0.2,0.2), the background color is medium grey (0.4,0.4,0.4), and there are no Camera objects, no camera animations, and no tree objects.

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

const nvmath::Vec3f & 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).
See also:
getAmbientColor, setBackColor

void setBackColor ( const nvmath::Vec3f & 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).
See also:
getBackColor, setAmbientColor,

size_t 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

const Camera * getCamera ( size_t index ) const [inline]

Get a Camera of the Scene.

Parameters:
index Index of the Camera to get.
Returns:
A pointer to the constant 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 ( const Camera * camera ) [inline]

Add a Camera to the list of predefined views.

Parameters:
camera A pointer to the constant Camera to add.
Remarks:
The reference count of camera is incremented.
See also:
getCamera, getNumberOfCameras, removeCamera

void removeCamera ( size_t 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

size_t 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

const Animation< nvmath::Trafo > * getCameraAnimation ( size_t index ) const [inline]

Get a camera animation of the Scene.

Parameters:
index Index of the camera animation to get.
Returns:
A pointer to the constant camera animation at index index.
Remarks:
A scene holds a list of camera animations, from which one can be selected for (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 ( const Animation< nvmath::Trafo > * animation ) [inline]

Add a camera animation.

Parameters:
animation A pointer to the constant 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 ( size_t 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

size_t getNumberOfFrames ( ) const [inline]

Get the number of animation frames.

Returns:
The number of animation frames in this Scene.
Remarks:
Currently, all animations in a scene must have the same number of frames.
See also:
getCameraAnimation

const Node * getRootNode ( ) const [inline]

Get the root node of the Scene.

Returns:
A pointer to the constant root Node of the Scene, or NULL if there is none.
See also:
setRootNode

NVSG_API void setRootNode ( const Node * root )

Set the root node of the Scene.

Parameters:
root A pointer to the constant Node to set as the root.
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

The documentation for this class was generated from the following file:
  • Scene.h
Generated on Fri Aug 4 08:38:34 2006 for NVSGSDK by NVIDIA


Member List

Scene Member List

This is the complete list of members for Scene, including all inherited members.
addCamera(const Camera *camera) | Scene | [inline]
addCameraAnimation(const Animation< nvmath::Trafo > *animation) | Scene | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
containsCgFx() const | Scene | [inline]
containsLight() const | Scene | [inline]
containsTransparentGeometry() const | Scene | [inline]
create() | Scene | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAmbientColor() const | Scene | [inline]
getBackColor() const | Scene | [inline]
getCamera(size_t index) const | Scene | [inline]
getCameraAnimation(size_t index) const | Scene | [inline]
getNumberOfCameraAnimations() const | Scene | [inline]
getNumberOfCameras() const | Scene | [inline]
getNumberOfFrames() const | Scene | [inline]
getRootNode() const | Scene | [inline]
IAllocator() | IAllocator | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
nvutil::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeCamera(size_t index) | Scene | [inline]
removeCameraAnimation(size_t index) | Scene | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
Scene() | Scene | [protected]
setAmbientColor(const nvmath::Vec3f &color) | Scene | [inline]
setBackColor(const nvmath::Vec3f &color) | Scene | [inline]
setRootNode(const Node *root) | Scene |
theAllocator typedef | IAllocator |
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Scene() | Scene | [protected, virtual]
Generated on Fri Aug 4 08:38:34 2006 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 const Scene * | load (const std::string &filename, const std::vector< std::string > &searchPaths, const ViewState *&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 const Scene* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | const ViewState *& | 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 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.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Fri Aug 4 08:38:22 2006 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]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, const ViewState *&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 Fri Aug 4 08:38:22 2006 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 (const Scene &scene, const ViewState *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 | ( | const Scene & | scene,
 |  | const ViewState * | 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.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Fri Aug 4 08:38:22 2006 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]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
save(const Scene &scene, const ViewState *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 Fri Aug 4 08:38:22 2006 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<
const nvsg::Object * > & 		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 | setBaseClassSearch (bool enable)
Enable/Disable the search for base classes.

Protected Member Functions

virtual NVSG_API | ~SearchTraverser (void)
Destructor.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
Set up the search and traverse the scene.

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.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Routine to handle a Group 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 | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Routine to handle a AnimatedQuads 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 | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Routine to handle a AnimatedTriangles 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 | handleParallelCamera (const nvsg::ParallelCamera *p, const nvsg::Node *root)
Routine to handle a ParallelCamera object while traversing the scene graph.

virtual NVSG_API void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p, const nvsg::Node *root)
Routine to handle a PerspectiveCamera 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 | handleFramedVNVectorAnimation (const nvsg::FramedAnimation< nvsg::VNVector > *p)
Routine to handle a FramedAnimation<VNVector> 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 | handleLinearInterpolatedVNVectorAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p)
Routine to handle a LinearInterpolatedAnimation<VNVector> 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< nvsg::VNVector > *p)
Search through an Animation<VNVector> 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::InterpolatedAnimation< nvmath::Trafo > *p)
Search through an InterpolatedAnimation<Trafo>.

virtual NVSG_API void | search (const nvsg::InterpolatedAnimation< nvsg::VNVector > *p)
Search through an InterpolatedAnimation<VNVector>.

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.

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< const nvsg::Object * > & 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 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 ( const nvsg::Scene * scene ) [protected, virtual]

Set up the search and traverse the scene.

Parameters:
scene scene to traverse

Reimplemented from Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

virtual NVSG_API void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Routine to handle a AnimatedQuads object while traversing the scene graph.

Parameters:
p Points to the currently visited AnimatedQuads object.

Reimplemented from Traverser.

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 Traverser.

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 Traverser.

virtual NVSG_API void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Routine to handle a AnimatedTriangles object while traversing the scene graph.

Parameters:
p Points to the currently visited AnimatedTriangles object.

Reimplemented from Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

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 Traverser.

virtual NVSG_API void handleParallelCamera | ( | const nvsg::ParallelCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Routine to handle a ParallelCamera object while traversing the scene graph.

Parameters:
p | Points to the currently visited ParallelCamera object.
root | If valid, points to the root node to be traversed with the actual camera settings.

Reimplemented from Traverser.

virtual NVSG_API void handlePerspectiveCamera | ( | const nvsg::PerspectiveCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Routine to handle a PerspectiveCamera object while traversing the scene graph.

Parameters:
p | Points to the currently visited PerspectiveCamera object.
root | If valid, points to the root node to be traversed with the actual camera settings.

Reimplemented from Traverser.

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 Traverser.

virtual NVSG_API void handleFramedVNVectorAnimation ( const nvsg::FramedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Routine to handle a FramedAnimation<VNVector> object while traversing the scene graph.

Parameters:
p Points to the currently visited Animation object.

Reimplemented from Traverser.

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 Traverser.

virtual NVSG_API void handleLinearInterpolatedVNVectorAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Routine to handle a LinearInterpolatedAnimation<VNVector> object while traversing the scene graph.

Parameters:
p Points to the currently visited Animation object.

Reimplemented from Traverser.

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< nvsg::VNVector > * p ) [protected, virtual]

Search through an Animation<VNVector> object.

This function is called when base class searching is enabled.

Parameters:
p Animation to search through

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::InterpolatedAnimation< nvmath::Trafo > * p ) [protected, virtual]

Search through an InterpolatedAnimation<Trafo>.

This function is called when base class searching is enabled.

Parameters:
p InterpolatedAnimation to search through

virtual NVSG_API void search ( const nvsg::InterpolatedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Search through an InterpolatedAnimation<VNVector>.

This function is called when base class searching is enabled.

Parameters:
p InterpolatedAnimation to search through

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

The documentation for this class was generated from the following file:
  • SearchTraverser.h
Generated on Fri Aug 4 08:39:39 2006 for NVSGSDK by NVIDIA


Member List

SearchTraverser Member List

This is the complete list of members for SearchTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | SearchTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getPaths(void) const | SearchTraverser | [inline]
getProblems() | Traverser |
getResults(void) const | SearchTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | SearchTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SearchTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | SearchTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | SearchTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [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]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | SearchTraverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | SearchTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | SearchTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *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 *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | SearchTraverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | SearchTraverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | 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 *p) | Traverser | [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 *p, size_t tu) | Traverser | [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]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
iterator typedef | SearchTraverser |
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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< nvsg::VNVector > *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::InterpolatedAnimation< nvmath::Trafo > *p) | SearchTraverser | [protected, virtual]
search(const nvsg::InterpolatedAnimation< nvsg::VNVector > *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]
SearchTraverser(void) | SearchTraverser |
setBaseClassSearch(bool enable) | SearchTraverser | [inline]
setClassName(const std::string &name) | SearchTraverser | [inline]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SearchTraverser(void) | SearchTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:39 2006 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

NVSG_API size_t | getNumberOfPrimitiveSets () const
Get the number of PrimitiveSet objects held by this Shape.

NVSG_API const PrimitiveSet * | getPrimitiveSet (size_t index) const
Get a pointer to a constant PrimitiveSet.

virtual NVSG_API const Shape * | clone () const=0
Interface for creating a new Shape by copying from this.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with another Shape.

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.

virtual NVSG_API | ~Shape ()
Protected destructor to prevent explicit creation.

NVSG_API void | addPrimitiveSet (const PrimitiveSet *p)
Add a PrimitiveSet to this Shape.

NVSG_API void | removePrimitiveSet (size_t index)
Remove a PrimitiveSet from this Shape.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere () const
Calculate the bounding sphere of this Shape.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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

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.

virtual NVSG_API ~Shape ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
This destructor is accessible only by derived classes. The reference count of the PrimitiveSet objects is decremented.

Member Function Documentation

size_t getNumberOfPrimitiveSets ( ) const [inline]

Get the number of PrimitiveSet objects held by this Shape.

Returns:
The number of PrimitiveSet objects.
See also:
getPrimitiveSet

const PrimitiveSet * getPrimitiveSet ( size_t index ) const [inline]

Get a pointer to a constant PrimitiveSet.

Parameters:
index Index of the PrimitiveSet to get.
Returns:
A pointer to the constant 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 const Shape* clone ( ) const [pure virtual]

Interface for creating a new Shape by copying from this.

Returns:
A pointer to a constant Shape.
Remarks:
The newly created Shape should be an exact copy of this.

Implements Drawable.

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.

NVSG_API void addPrimitiveSet ( const PrimitiveSet * p ) [protected]

Add a PrimitiveSet to this Shape.

Parameters:
p A pointer to the constant 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 ( size_t index ) [protected]

Remove a PrimitiveSet from this Shape.

Parameters:
index Index of the PrimitiveSet to remove.
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::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.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 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 Fri Aug 4 08:38:35 2006 for NVSGSDK by NVIDIA


Member List

Shape Member List

This is the complete list of members for Shape, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addPrimitiveSet(const PrimitiveSet *p) | Shape | [protected]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | Shape | [protected, virtual]
clone() const=0 | Shape | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfPrimitiveSets() const | Shape | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getPrimitiveSet(size_t index) const | Shape | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Shape | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const Shape &rhs) | Shape | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removePrimitiveSet(size_t index) | Shape | [protected]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
Shape() | Shape | [protected]
Shape(const Shape &rhs) | Shape | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Shape | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Shape() | Shape | [protected, virtual]
Generated on Fri Aug 4 08:38:35 2006 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

size_t | shortStrippedCount
The number of objects with short strips.

size_t | 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

size_t shortStrippedCount

The number of objects with short strips.

size_t shortStrippedNumber

The number of short strips in those objects.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:06 2006 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 Fri Aug 4 08:39:06 2006 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

size_t | 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

size_t singleChildCount

The number of objects with a single child.

The documentation for this class was generated from the following file:
  • AnalyzeTraverser.h
Generated on Fri Aug 4 08:39:06 2006 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 Fri Aug 4 08:39:06 2006 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 Fri Aug 4 08:40:19 2006 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 Fri Aug 4 08:40:19 2006 for NVSGSDK by NVIDIA


Skin Struct Reference

Internal helper class for SkinnedTriangles. More...

#include <SkinnedTriangles.h>

Collaboration diagram for 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 Fri Aug 4 08:38:35 2006 for NVSGSDK by NVIDIA


Member List

Skin Member List

This is the complete list of members for Skin, including all inherited members.
m_bones | Skin
m_normal | Skin
m_vertex | Skin
Generated on Fri Aug 4 08:38:35 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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

virtual NVSG_API const SkinnedTriangles * | clone () const
Create a new SkinnedTriangles by copying from this.

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.

virtual NVSG_API size_t | getNumberOfFrames () const
Get the number of animation frames that are part of this SkinnedTriangles.

NVSG_API void | setAnimationFrame (size_t frame, bool calculateTangentSpace)
Set the current frame.

NVSG_API size_t | 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 Skin *skins, size_t numSkins)
Set the skins.

NVSG_API void | setSkins (size_t pos, const Skin *skins, size_t 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.

Static Public Member Functions

NVSG_API const SkinnedTriangles * | create ()
Create a SkinnedTriangles.

NVSG_API const SkinnedTriangles * | createFromBase (const Triangles &rhs)
Create a SkinnedTriangles by copying from a Triangles.

Protected Member Functions

NVSG_API | SkinnedTriangles ()
Protected constructor to prevent explicit creation.

NVSG_API | SkinnedTriangles (const Triangles &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | SkinnedTriangles (const SkinnedTriangles &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~SkinnedTriangles ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside SkinnedTriangles::create.

NVSG_API SkinnedTriangles ( const Triangles & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Triangles to use as a base of the new SkinnedTriangles
Remarks:
This constructor is never used explicitly, but only inside SkinnedTriangles::createFromBase.
See also:
Triangles

NVSG_API SkinnedTriangles ( const SkinnedTriangles & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant SkinnedTriangles to copy from
Remarks:
This constructor is never used explicitly, but only inside SkinnedTriangles::create.

virtual NVSG_API ~SkinnedTriangles ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the SkinnedTriangles is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const SkinnedTriangles* create ( ) [static]

Create a SkinnedTriangles.

Returns:
A pointer to a constant SkinnedTriangles.
Remarks:
By default, a SkinnedTriangles is empty.

Reimplemented from Triangles.

NVSG_API const SkinnedTriangles* createFromBase ( const Triangles & rhs ) [static]

Create a SkinnedTriangles by copying from a Triangles.

Parameters:
rhs A reference to the constant Triangles to copy from
Returns:
A pointer to a constant SkinnedTriangles.
Remarks:
All the data from the Triangles rhs is used as the base information for the newly created SkinnedTriangles. There is no skinning information created.
See also:
Skin, Triangles

virtual NVSG_API const SkinnedTriangles* clone ( ) const [virtual]

Create a new SkinnedTriangles by copying from this.

Returns:
A pointer to a constant SkinnedTriangles.
Remarks:
The newly created SkinnedTriangles is an exact copy of this.

Reimplemented from Triangles.

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.

virtual NVSG_API size_t getNumberOfFrames ( ) const [virtual]

Get the number of animation frames that are part of this SkinnedTriangles.

Returns:
Number of frames in the Animation.

Reimplemented from Drawable.

NVSG_API void setAnimationFrame | ( | size_t | 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 behaviour 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

size_t 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 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 Skin * | skins,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const Skin * | skins,
 |  | size_t | 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 specifiy (-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 void validateIncarnation ( ) const [protected, 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.

The documentation for this class was generated from the following file:
  • SkinnedTriangles.h
Generated on Fri Aug 4 08:38:37 2006 for NVSGSDK by NVIDIA


Member List

SkinnedTriangles Member List

This is the complete list of members for SkinnedTriangles, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(const Triangles *t, size_t tu=0, size_t tg=1, size_t bn=2) | Triangles | [related]
clone() const | SkinnedTriangles | [virtual]
create() | SkinnedTriangles | [static]
createFromBase(const Triangles &rhs) | SkinnedTriangles | [static]
nvsg::Triangles::createFromBase(const IndependentPrimitiveSet &rhs) | Triangles | [static]
nvsg::Triangles::createFromBase(const PrimitiveSet &rhs) | Triangles | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const Triangles *q) | Triangles | [related]
getBoundingSphere(void) const | Drawable |
getDataID() const | SkinnedTriangles | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFaces() const | Triangles | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFaces() const | Triangles | [inline]
getNumberOfFrames() const | SkinnedTriangles | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfSkins() const | SkinnedTriangles | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getSkins() const | SkinnedTriangles | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Triangles | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | SkinnedTriangles | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | SkinnedTriangles | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAnimationFrame(size_t frame, bool calculateTangentSpace) | SkinnedTriangles |
setFaces(const Face3 *faces, size_t numFaces) | Triangles | [inline]
setFaces(size_t pos, const Face3 *faces, size_t numFaces) | Triangles | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setSkins(const Skin *skins, size_t numSkins) | SkinnedTriangles |
setSkins(size_t pos, const Skin *skins, size_t numSkins) | SkinnedTriangles |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
SkinnedTriangles() | SkinnedTriangles | [protected]
SkinnedTriangles(const Triangles &rhs) | SkinnedTriangles | [protected]
SkinnedTriangles(const SkinnedTriangles &rhs) | SkinnedTriangles | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
Triangles() | Triangles | [protected]
Triangles(const IndependentPrimitiveSet &rhs) | Triangles | [protected]
Triangles(const PrimitiveSet &rhs) | Triangles | [protected]
Triangles(const Triangles &rhs) | Triangles | [protected]
validateIncarnation() const | SkinnedTriangles | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SkinnedTriangles() | SkinnedTriangles | [protected, virtual]
~Triangles() | Triangles | [protected, virtual]
Generated on Fri Aug 4 08:38:37 2006 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 (const nvsg::Scene *scene)
doApply override

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Handle a GeoNode object.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
Handle a Quads object.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
Handle a Triangles object.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Handle a QuadStrips object.

virtual NVSG_API void | handleTriFans (const nvsg::TriFans *p)
Handle a TriFans object.

virtual NVSG_API void | handleTriStrips (const 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 ( const nvsg::Scene * scene ) [protected, virtual]

doApply override

Reimplemented from Traverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Handle a GeoNode object.

The GeoNode is the primary object to smooth.

Parameters:
p GeoNode to handle

Reimplemented from Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Handle a Quads object.

Parameters:
p Quads to handle

Reimplemented from Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Handle a Triangles object.

Parameters:
p Triangles to handle

Reimplemented from Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Handle a QuadStrips object.

Just assert here; shouldn't happen at all!

Parameters:
p QuadStrips to handle

Reimplemented from Traverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Handle a TriFans object.

Just assert here; shouldn't happen at all!

Parameters:
p TriFans to handle

Reimplemented from Traverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Handle a TriStrips object.

Just assert here; shouldn't happen at all!

Parameters:
p TriStrips to handle

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • SmoothTraverser.h
Generated on Fri Aug 4 08:39:41 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | SmoothTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | SmoothTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | SmoothTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | SmoothTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | SmoothTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | SmoothTraverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | SmoothTraverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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 |
SmoothTraverser(void) | SmoothTraverser |
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SmoothTraverser(void) | SmoothTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:41 2006 for NVSGSDK by NVIDIA


Sphere3f Class Reference

Sphere class. More...

#include <Sphere3f.h>

Collaboration diagram for Sphere3f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Sphere3f (void)
Default constructor.

NVSG_API | Sphere3f (const Vec3f &center, float radius)
Constructor by center and radius.

NVSG_API Sphere3f & | operator= (const Sphere3f &s)
Assignment operator.

NVSG_API bool | operator== (const Sphere3f &s) const
Equality operator.

NVSG_API bool | operator!= (const Sphere3f &s) const
Inequality operator.

NVSG_API float | operator() (const Vec3f &p) const
Calling operator.

NVSG_API const Vec3f & | getCenter (void) const
Get the center of the sphere.

NVSG_API void | setCenter (const Vec3f &center)
Set the center of the sphere.

NVSG_API float | getRadius (void) const
Get the radius of the sphere.

NVSG_API void | setRadius (float radius)
Set the radius of the sphere.

Related Functions

(Note that these are not member functions.)

NVSG_API Sphere3f | boundingSphere (const Vec3f *points, size_t numberOfPoints)
NVSG_API Sphere3f | boundingSphere (const Vec3f *points, const unsigned int *indices, size_t numberOfIndices)
NVSG_API Sphere3f | boundingSphere (const Vec3f *points, const std::vector< unsigned int > *strips, size_t numberOfStrips)
NVSG_API Sphere3f | boundingSphere (const Sphere3f &s, const Vec3f &p)
NVSG_API Sphere3f | boundingSphere (const Sphere3f &s0, const Sphere3f &s1)
NVSG_API Sphere3f | intersectingSphere (const Sphere3f &s0, const Sphere3f &s1)
void | invalidate (Sphere3f &s)
bool | isEmpty (const Sphere3f &s)

Detailed Description

Sphere class.

This is a sphere in 3-space, determined by a center point and a radius.
A Sphere3f 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

NVSG_API Sphere3f ( void )

Default constructor.

A default sphere is initialized to be invalid.
A Sphere3f is considered to be invalid if the radius is negative.

NVSG_API Sphere3f | ( | const Vec3f & | center,
 |  | float | radius
 | ) |

Constructor by center and radius.

Parameters:
center | center
radius | radius

Member Function Documentation

Sphere3f & operator= ( const Sphere3f & s ) [inline]

Assignment operator.

Returns:
reference to the assigned sphere
Parameters:
s sphere to assign

bool operator== ( const Sphere3f & s ) const [inline]

Equality operator.

Two Sphere3f are considered to be equal, if the center points are equal and the radii differ by less than epsilon.

Returns:
true if the sphere is equal to s, otherwise false
Parameters:
s sphere to compare with

bool operator!= ( const Sphere3f & s ) const [inline]

Inequality operator.

Two Sphere3f are considered to be equal, if the center points are equal and the radii differ by less than epsilon.

Returns:
true if the sphere is not equal to s, otherwise false
Parameters:
s sphere to compare with

float operator() ( const Vec3f & p ) const [inline]

Calling operator.

Calculates the distance of a point to the sphere. When the point is inside the sphere, the distance is negative; when the point is outside, the distance is positive.

Returns:
the signed distance of p to the sphere.
Parameters:
p point to determine distance from sphere

const Vec3f & getCenter ( void ) const [inline]

Get the center of the sphere.

Returns:
the center of the sphere.

void setCenter ( const Vec3f & center ) [inline]

Set the center of the sphere.

Parameters:
center point to set as center

float getRadius ( void ) const [inline]

Get the radius of the sphere.

Returns:
the radius of the sphere.

void setRadius ( float radius ) [inline]

Set the radius of the sphere.

Parameters:
radius radius to set

Friends And Related Function Documentation

NVSG_API Sphere3f boundingSphere | ( | const Vec3f * | points,
 |  | size_t | numberOfPoints
 | ) | [related]

Determine a bounding sphere of a number of points

Note:
The determined sphere is not necessarily the smallest possible.
Returns:
A reasonable small sphere around the given points
Parameters:
points | points to to include
numberOfPoints | number of points

NVSG_API Sphere3f boundingSphere | ( | const Vec3f * | points,
 |  | const unsigned int * | indices,
 |  | size_t | numberOfIndices
 | ) | [related]

Determine the bounding sphere of a number of indexed points.

Note:
The determined sphere is not necessarily the smallest possible.
Returns:
A reasonable small sphere around the given points
Parameters:
points | points to use
indices | indices to use in points
numberOfIndices | number of indices

NVSG_API Sphere3f boundingSphere | ( | const Vec3f * | points,
 |  | const std::vector< unsigned int > * | strips,
 |  | size_t | numberOfStrips
 | ) | [related]

Determine the bounding sphere of a number of strip-indexed points.

Note:
The determined sphere is not necessarily the smallest possible.
Returns:
A reasonable small sphere around the given points
Parameters:
points | points to use
strips | strips of indices to use in points
numberOfStrips | number of strips

NVSG_API Sphere3f boundingSphere | ( | const Sphere3f & | s,
 |  | const Vec3f & | p
 | ) | [related]

Determine the bounding sphere around a sphere s and a point p.

Returns:
The bounding sphere around s and p.

NVSG_API Sphere3f boundingSphere | ( | const Sphere3f & | s0,
 |  | const Sphere3f & | s1
 | ) | [related]

Determine the bounding sphere around two given spheres.

Returns:
the smallest sphere that includes both given spheres s0 and s1.

NVSG_API Sphere3f intersectingSphere | ( | const Sphere3f & | s0,
 |  | const Sphere3f & | s1
 | ) | [related]

Determine the bounding sphere of the intersection of two given spheres.

Returns:
the smallest sphere that includes the intersection of the two spheres s0 and s1.

void invalidate ( Sphere3f & s ) [related]

Invalidate a Sphere3f.
A Sphere3f is invalidated by setting it's radius to minus one.

Parameters:
s sphere to invalidate

bool isEmpty ( const Sphere3f & s ) [related]

Check if the given sphere is an empty sphere.
A sphere is considered to be empty if the radius is not negative.

Parameters:
s sphere to test

The documentation for this class was generated from the following file:
  • Sphere3f.h
Generated on Fri Aug 4 08:37:23 2006 for NVSGSDK by NVIDIA


Member List

Sphere3f Member List

This is the complete list of members for Sphere3f, including all inherited members.
boundingSphere(const Vec3f *points, size_t numberOfPoints) | Sphere3f | [related]
boundingSphere(const Vec3f *points, const unsigned int *indices, size_t numberOfIndices) | Sphere3f | [related]
boundingSphere(const Vec3f *points, const std::vector< unsigned int > *strips, size_t numberOfStrips) | Sphere3f | [related]
boundingSphere(const Sphere3f &s, const Vec3f &p) | Sphere3f | [related]
boundingSphere(const Sphere3f &s0, const Sphere3f &s1) | Sphere3f | [related]
getCenter(void) const | Sphere3f | [inline]
getRadius(void) const | Sphere3f | [inline]
intersectingSphere(const Sphere3f &s0, const Sphere3f &s1) | Sphere3f | [related]
invalidate(Sphere3f &s) | Sphere3f | [related]
isEmpty(const Sphere3f &s) | Sphere3f | [related]
operator!=(const Sphere3f &s) const | Sphere3f | [inline]
operator()(const Vec3f &p) const | Sphere3f | [inline]
operator=(const Sphere3f &s) | Sphere3f | [inline]
operator==(const Sphere3f &s) const | Sphere3f | [inline]
setCenter(const Vec3f &center) | Sphere3f | [inline]
setRadius(float radius) | Sphere3f | [inline]
Sphere3f(void) | Sphere3f |
Sphere3f(const Vec3f &center, float radius) | Sphere3f |
Generated on Fri Aug 4 08:37:23 2006 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

virtual NVSG_API const SpotLight * | clone () const
Create a new SpotLight by copying from this.

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.

Static Public Member Functions

NVSG_API const SpotLight * | create ()
Create a SpotLight.

NVSG_API const SpotLight * | createFromBase (const LightSource &rhs)
Create a SpotLight by copying from a LightSource.

Protected Member Functions

NVSG_API | SpotLight ()
Protected default constructor to prevent explicit creation.

NVSG_API | SpotLight (const LightSource &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | SpotLight (const SpotLight &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~SpotLight ()
Protected destructor to prevent explicit creation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside SpotLight::create.

NVSG_API SpotLight ( const LightSource & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant LightSource to use as a base of the new SpotLight
Remarks:
This constructor is never used explicitly, but only inside SpotLight::createFromBase.
See also:
LightSource

NVSG_API SpotLight ( const SpotLight & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs Reference to the constant SpotLight to copy from
Remarks:
This constructor is never used explicitly, but only inside SpotLight::create.

virtual NVSG_API ~SpotLight ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the SpotLight is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const SpotLight* create ( ) [static]

Create a SpotLight.

Returns:
A pointer to a constant SpotLight.
Remarks:
A SpotLight with default settings is created.
See also:
LightSource

NVSG_API const SpotLight* createFromBase ( const LightSource & rhs ) [static]

Create a SpotLight by copying from a LightSource.

Parameters:
rhs A reference to the constant LightSource to copy from
Returns:
A pointer to a constant SpotLight.
Remarks:
All the data from the LightSource rhs is used as the base information for the newly created DirectedLight. SpotLight specific data is initialized as if SpotLight::create was called.
See also:
LightSource

virtual NVSG_API const SpotLight* clone ( ) const [virtual]

Create a new SpotLight by copying from this.

Returns:
A pointer to a constant SpotLight.
Remarks:
The newly created SpotLight is an exact copy of this.

Implements LightSource.

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

void setPosition ( const nvmath::Vec3f & position ) [inline]

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

void setOrientation ( const nvmath::Quatf & orientation ) [inline]

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 radians.
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 radians.
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 reference to the constant 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 Fri Aug 4 08:38:38 2006 for NVSGSDK by NVIDIA


Member List

SpotLight Member List

This is the complete list of members for SpotLight, including all inherited members.
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere() const | LightSource | [protected, virtual]
clone() const | SpotLight | [virtual]
containsCgFx() const | Node | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | LightSource | [virtual]
containsTransparentGeometry() const | Node |
create() | SpotLight | [static]
createFromBase(const LightSource &rhs) | SpotLight | [static]
determineHintsContainment(unsigned short hints) const | Node | [protected, virtual]
determineTransparencyContainment() const | LightSource | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAmbientColor() const | LightSource | [inline]
getAnimation() const | LightSource | [inline]
getAnnotation() const | Node |
getAttenuation(float &c, float &l, float &q) const | SpotLight | [inline]
getAttenuation() const | SpotLight | [inline]
getBoundingSphere() const | Node |
getCutoffAngle() const | SpotLight | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getDiffuseColor() const | LightSource | [inline]
getDirection() const | SpotLight | [inline]
getFalloffExponent() const | SpotLight | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getIntensity() const | LightSource | [inline]
getInverse() const | LightSource | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames() const | LightSource | [inline, virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getOrientation() const | SpotLight | [inline]
getParent(size_t index) const | Node | [inline]
getPosition() const | SpotLight | [inline]
getSpecularColor() const | LightSource | [inline]
getTransformationMatrix() const | LightSource | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCgFxContainment() | Node | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Node | [virtual]
invalidateNumberOfFrames() const | Node | [virtual]
invalidateTransparencyContainment() | Node |
isAttenuated() const | SpotLight | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | SpotLight | [virtual]
isShadowCasting() const | LightSource | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
LightSource() | LightSource | [protected]
LightSource(const LightSource &rhs) | LightSource | [protected]
m_objectCode | Object | [protected]
m_trafo | LightSource | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const SpotLight &rhs) | SpotLight |
nvsg::LightSource::operator=(const LightSource &rhs) | LightSource | [protected]
nvsg::Node::operator=(const Node &rhs) | Node | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAmbientColor(const nvmath::Vec3f &color) | LightSource | [inline]
setAnimation(const Animation< nvmath::Trafo > *animation) | LightSource |
setAnimationFrame(size_t frame) | LightSource |
setAnnotation(const std::string &anno) | Node |
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 |
setFalloffExponent(float fe) | SpotLight | [inline]
setHints(unsigned short hints) | Node | [inline]
setIntensity(float intensity) | LightSource | [inline]
setName(const std::string &name) | Object |
setOrientation(const nvmath::Quatf &orientation) | SpotLight | [inline]
setPosition(const nvmath::Vec3f &position) | SpotLight | [inline]
setShadowCasting(bool cast) | LightSource | [inline]
setSpecularColor(const nvmath::Vec3f &color) | LightSource | [inline]
SpotLight() | SpotLight | [protected]
SpotLight(const LightSource &rhs) | SpotLight | [protected]
SpotLight(const SpotLight &rhs) | SpotLight | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | LightSource | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~LightSource() | LightSource | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SpotLight() | SpotLight | [protected, virtual]
Generated on Fri Aug 4 08:38:38 2006 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 const StateAttribute * | clone (void) const=0
Interface for creating a new StateAttribute by copying from this.

NVSG_API size_t | getNumberOfParents (void) const
Get the number of parents of this StateAttribute.

NVSG_API const StatePass * | getParent (size_t index) const
Get a pointer to the constant parent StatePass at position index.

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.

virtual NVSG_API | ~StateAttribute (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API void | invalidateIncarnation (void)
Invalidate the nvutil::Incarnation.

NVSG_API StateAttribute & | operator= (const StateAttribute &rhs)
Assignment operator.

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

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 Object is called, but the parents of rhs are not copied.

virtual NVSG_API ~StateAttribute ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
This destructor is accessible only by derived classes.

Member Function Documentation

virtual NVSG_API const StateAttribute* clone ( void ) const [pure virtual]

Interface for creating a new StateAttribute by copying from this.

Returns:
A pointer to a constant StateAttribute.
Remarks:
The newly created StateAttribute should be an exact copy of this.

Implemented in BlendAttribute, CgFx, DepthAttribute, FaceAttribute, LineAttribute, Material, PointAttribute, and TextureAttribute.

size_t getNumberOfParents ( void ) const [inline]

Get the number of parents of this StateAttribute.

Returns:
The number of parents of this StateAttribute.
See also:
StatePass, getParent

const StatePass * getParent ( size_t index ) const [inline]

Get a pointer to the constant parent StatePass at position index.

Parameters:
index The index of the StatePass to get.
Returns:
A pointer to the constant parent StatePass at position index.
Note:
The behavior is undefined if index is larger than or equal to the number of parents of this StateAttribute.
See also:
StatePass, getNumberOfParents

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 BlendAttribute, and CgFx.

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

virtual NVSG_API void invalidateIncarnation ( void ) [protected, virtual]

Invalidate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this StateAttribute has increased and now is to be marked as invalid. It first increases the nvutil::Incarnation of all its parents, then its own nvutil::Incarnation is marked as invalid.
See also:
nvutil::Incarnation, StatePass

Reimplemented from Object.

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 Object. The parents of rhs are not copied.

The documentation for this class was generated from the following file:
  • StateAttribute.h
Generated on Fri Aug 4 08:38:39 2006 for NVSGSDK by NVIDIA


Member List

StateAttribute Member List

This is the complete list of members for StateAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone(void) const=0 | StateAttribute | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *object, bool ignoreNames=true, bool deepCompare=false) const | Object | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
Generated on Fri Aug 4 08:38:39 2006 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

virtual NVSG_API const StatePass * | clone () const
Create a new StatePass by copying from this.

NVSG_API size_t | getNumberOfOwners () const
Get the number of owners of this StatePass.

NVSG_API const StateVariant * | getOwner (size_t index) const
Get a pointer to the constant owning StateVariant at position index.

NVSG_API size_t | getNumberOfAttributes () const
Get the number of StateAttribute objects in this StatePass.

NVSG_API const StateAttribute * | getAttribute (size_t index) const
Get the StateAttribute at the specified position.

NVSG_API const StateAttribute * | getAttributeByObjectCode (unsigned int objectCode) const
Get the StateAttribute with the object code objectCode.

NVSG_API size_t | getAttributeIndex (const StateAttribute *attribute) const
Get the index of the specified StateAttribute in this StatePass.

NVSG_API void | addAttribute (const StateAttribute *attribute)
Add a StateAttribute to this StatePass.

NVSG_API void | removeAttribute (size_t index)
Remove the StateAttribute at the specified position.

NVSG_API void | removeAttribute (const StateAttribute *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.

Static Public Member Functions

NVSG_API const StatePass * | create ()
Create a StatePass.

NVSG_API const StatePass * | createFromBase (const Object &rhs)
Create a StatePass by copying from an Object.

Protected Member Functions

NVSG_API | StatePass ()
Protected default constructor to prevent explicit creation.

NVSG_API | StatePass (const Object &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | StatePass (const StatePass &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~StatePass ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | invalidateIncarnation ()
Invalidate the nvutil::Incarnation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside StatePass::create.

NVSG_API StatePass ( const Object & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Object to use as a base of the new StatePass.
Remarks:
This constructor is never used explicitly, but only inside StatePass::createFromBase.
See also:
Object

NVSG_API StatePass ( const StatePass & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StatePass to copy from
Remarks:
This constructor is never used explicitly, but only inside StatePass::create.

virtual NVSG_API ~StatePass ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the StatePass is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const StatePass* create ( ) [static]

Create a StatePass.

Returns:
A pointer to a constant StatePass.
Remarks:
An empty StatePass is created.
See also:
Object

NVSG_API const StatePass* createFromBase ( const Object & rhs ) [static]

Create a StatePass by copying from an Object.

Parameters:
rhs A reference to the constant StatePass to copy from.
Returns:
A pointer to a constant StatePass.
Remarks:
All the data from the Object rhs is used as the base information for the newly created StatePass. The created StatePass then is empty.
See also:
Object

virtual NVSG_API const StatePass* clone ( ) const [virtual]

Create a new StatePass by copying from this.

Returns:
A pointer to a constant StatePass.
Remarks:
The newly created StatePass is an exact copy of this.

size_t getNumberOfOwners ( ) const [inline]

Get the number of owners of this StatePass.

Returns:
The number of owners of this StatePass.
See also:
StateVariant, getOwner

const StateVariant * getOwner ( size_t index ) const [inline]

Get a pointer to the constant owning StateVariant at position index.

Parameters:
index The index of the StateVariant to get.
Returns:
A pointer to the constant owning StateVariant at position index.
Note:
The behavior is undefined if index is larger than or equal to the number of owners of this StatePass.
See also:
StateVariant, getNumberOfOwners

size_t 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

const StateAttribute * getAttribute ( size_t 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 const StateAttribute* 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

size_t getAttributeIndex ( const StateAttribute * 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 ( const StateAttribute * 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 ( size_t 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 ( const StateAttribute * 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 Object. Then any StateAttribute attached to this StatePass is removed, and all StateAttribute objects of rhs are copied.
See also:
Object, 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 void invalidateIncarnation ( ) [protected, virtual]

Invalidate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this StatePass has increased and now is to be marked as invalid. It first increases the nvutil::Incarnation of all its owners, then its own nvutil::Incarnation is marked as invalid.
See also:
nvutil::Incarnation, validateIncarnation

Reimplemented from Object.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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.

The documentation for this class was generated from the following file:
  • StatePass.h
Generated on Fri Aug 4 08:38:40 2006 for NVSGSDK by NVIDIA


Member List

StatePass Member List

This is the complete list of members for StatePass, including all inherited members.
addAttribute(const StateAttribute *attribute) | StatePass |
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | StatePass | [virtual]
containsCgFx() const | StatePass |
create() | StatePass | [static]
createFromBase(const Object &rhs) | StatePass | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAttribute(size_t index) const | StatePass | [inline]
getAttributeByObjectCode(unsigned int objectCode) const | StatePass |
getAttributeIndex(const StateAttribute *attribute) const | StatePass | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfAttributes() const | StatePass | [inline]
getNumberOfOwners() const | StatePass | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | StatePass | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateCgFxContainment() | StatePass |
invalidateIncarnation() | StatePass | [protected, virtual]
invalidateTransparencyContainment() | StatePass |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StatePass | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent() const | StatePass |
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const StatePass &rhs) | StatePass |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeAttribute(size_t index) | StatePass |
removeAttribute(const StateAttribute *attribute) | StatePass |
removeAttributeByObjectCode(unsigned int objectCode) | StatePass |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
StatePass() | StatePass | [protected]
StatePass(const Object &rhs) | StatePass | [protected]
StatePass(const StatePass &rhs) | StatePass | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | StatePass | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StatePass() | StatePass | [protected, virtual]
Generated on Fri Aug 4 08:38:40 2006 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

virtual NVSG_API const StateSet * | clone () const
Create a new StateSet by copying from this.

NVSG_API size_t | getNumberOfOwners () const
Get the number of owners of this StateSet.

NVSG_API const GeoNode * | getOwner (size_t index) const
Get a pointer to the constant owner at position index.

NVSG_API size_t | 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 const StateVariant * | getActiveVariant () const
Get the currently active StateVariant.

NVSG_API const StateVariant * | getVariant (VariantKey key) const
Get the StateVariant associated with the specified VariantKey.

NVSG_API const StateVariant * | 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 (const StateVariant *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, const StateVariant *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 size_t | getNumberOfPasses (VariantKey key=0) const
Get the number of StatePass objects in the specified StateVariant.

NVSG_API const StatePass * | getPass (size_t passIndex, VariantKey key=0) const
Get the StatePass at the specified position in the StateVariant associated with key.

NVSG_API void | addPass (const StatePass *pass, VariantKey key=0)
Add a StatePass to the StateVariant associated with key.

NVSG_API void | removePass (size_t passIndex, VariantKey key=0)
Remove the StatePass at the specified position from the StateVariant associated with key.

NVSG_API void | replacePass (const StatePass *pass, size_t passIndex, VariantKey key=0)
Replace the StatePass at the specified position in the StateVariant associated with key.

NVSG_API size_t | getNumberOfAttributes (size_t passIndex=0, VariantKey key=0) const
Get the number of StateAttribute objects in the specified StatePass.

NVSG_API const StateAttribute * | getAttribute (size_t attributeIndex, size_t passIndex=0, VariantKey key=0) const
Get the StateAttribute at the specified position.

NVSG_API const StateAttribute * | getAttributeByObjectCode (unsigned int objectCode, size_t passIndex=0, VariantKey key=0) const
Get the StateAttribute with the object code objectCode in the specified StatePass.

NVSG_API size_t | getAttributeIndex (const StateAttribute *attribute, size_t passIndex=0, VariantKey key=0) const
Get the index of the StateAttribute in the specified StatePass.

NVSG_API void | addAttribute (const StateAttribute *attribute, size_t passIndex=0, VariantKey key=0)
Add a StateAttribute to the specified StatePass.

NVSG_API void | removeAttribute (size_t attributeIndex, size_t passIndex=0, VariantKey key=0)
Remove the StateAttribute at the specified position.

NVSG_API void | removeAttribute (const StateAttribute *attribute, size_t passIndex=0, VariantKey key=0)
Remove the given StateAttribute from the specified StatePass.

NVSG_API void | removeAttributeByObjectCode (unsigned int objectCode, size_t 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 | 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.

Static Public Member Functions

NVSG_API const StateSet * | create ()
Create a StateSet.

NVSG_API const StateSet * | createFromBase (const Object &rhs)
Create a StateSet by copying from an Object.

Protected Member Functions

NVSG_API | StateSet ()
Protected default constructor to prevent explicit creation.

NVSG_API | StateSet (const Object &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | StateSet (const StateSet &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~StateSet ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | invalidateIncarnation ()
Invalidate the nvutil::Incarnation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside StateSet::create.

NVSG_API StateSet ( const Object & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Object to use as a base of the new StateSet.
Remarks:
This constructor is never used explicitly, but only inside StateSet::createFromBase.
See also:
Object

NVSG_API StateSet ( const StateSet & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StateSet to copy from
Remarks:
This constructor is never used explicitly, but only inside StateSet::create.

virtual NVSG_API ~StateSet ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the StateSet is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const StateSet* create ( ) [static]

Create a StateSet.

Returns:
A pointer to a constant StateSet.
Remarks:
An empty StateSet with an invalid key is created.
See also:
Object

NVSG_API const StateSet* createFromBase ( const Object & rhs ) [static]

Create a StateSet by copying from an Object.

Parameters:
rhs A reference to the constant StateSet to copy from.
Returns:
A pointer to a constant StateSet.
Remarks:
All the data from the Object rhs is used as the base information for the newly created StateSet. The created StateSet, then, is empty and has an invalid key.
See also:
Object

virtual NVSG_API const StateSet* clone ( ) const [virtual]

Create a new StateSet by copying from this.

Returns:
A pointer to a constant StateSet.
Remarks:
The newly created StateSet is an exact copy of this.

size_t getNumberOfOwners ( ) const [inline]

Get the number of owners of this StateSet.

Returns:
The number of owners of this StateSet.
See also:
StateSet, getOwner

const GeoNode * getOwner ( size_t index ) const [inline]

Get a pointer to the constant owner at position index.

Parameters:
index The index of the owner to get.
Returns:
A pointer to the constant owning StateSet at position index.
Note:
The behavior is undefined if index is larger than or equal to the number of owners of this StateVariant.
See also:
StateSet, getNumberOfOwners

size_t 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

const StateVariant * 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

const StateVariant * 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

const StateVariant * 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.
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.
See also:
VariantKey, getActiveVariant, getActiveVariantKey

NVSG_API void addVariant | ( | const StateVariant * | 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.
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,
 |  | const StateVariant * | 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

size_t 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

const StatePass * getPass | ( | size_t | 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 | ( | const StatePass * | 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 | ( | size_t | 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 | ( | const StatePass * | pass,
 |  | size_t | 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

size_t getNumberOfAttributes | ( | size_t | 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

const StateAttribute * getAttribute | ( | size_t | attributeIndex,
 |  | size_t | 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

const StateAttribute * getAttributeByObjectCode | ( | unsigned int | objectCode,
 |  | size_t | 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

size_t getAttributeIndex | ( | const StateAttribute * | attribute,
 |  | size_t | 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 | ( | const StateAttribute * | attribute,
 |  | size_t | 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 | ( | size_t | attributeIndex,
 |  | size_t | 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 | ( | const StateAttribute * | attribute,
 |  | size_t | 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,
 |  | size_t | 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 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 Object. Then any StateVariant attached to this StateSet is removed, and all StateVariant objects of rhs are copied.
See also:
Object, 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 void invalidateIncarnation ( ) [protected, virtual]

Invalidate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this StateSet has increased and now is to be marked as invalid. It first increases the nvutil::Incarnation of all it's owners, then it's own nvutil::Incarnation is marked as invalid.
See also:
nvutil::Incarnation, validateIncarnation

Reimplemented from Object.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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 Fri Aug 4 08:38:42 2006 for NVSGSDK by NVIDIA


Member List

StateSet Member List

This is the complete list of members for StateSet, including all inherited members.
addAttribute(const StateAttribute *attribute, size_t passIndex=0, VariantKey key=0) | StateSet |
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addPass(const StatePass *pass, VariantKey key=0) | StateSet |
addRef() const | RCObject | [inline]
addVariant(const StateVariant *variant, VariantKey key) | StateSet |
clone() const | StateSet | [virtual]
containsCgFx() const | StateSet |
create() | StateSet | [static]
createFromBase(const Object &rhs) | StateSet | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getActiveVariant() const | StateSet | [inline]
getActiveVariantKey() const | StateSet | [inline]
getAttribute(size_t attributeIndex, size_t passIndex=0, VariantKey key=0) const | StateSet | [inline]
getAttributeByObjectCode(unsigned int objectCode, size_t passIndex=0, VariantKey key=0) const | StateSet | [inline]
getAttributeIndex(const StateAttribute *attribute, size_t passIndex=0, VariantKey key=0) const | StateSet | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFirstVariantIterator() const | StateSet | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getLastVariantIterator() const | StateSet | [inline]
getName() const | Object |
getNextVariantIterator(VariantIterator it) const | StateSet | [inline]
getNumberOfAttributes(size_t passIndex=0, VariantKey key=0) const | StateSet | [inline]
getNumberOfOwners() const | StateSet | [inline]
getNumberOfPasses(VariantKey key=0) const | StateSet | [inline]
getNumberOfVariants() const | StateSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | StateSet | [inline]
getPass(size_t passIndex, VariantKey key=0) const | StateSet | [inline]
getVariant(VariantKey key) const | StateSet | [inline]
getVariant(VariantIterator it) const | StateSet | [inline]
getVariantKey(VariantIterator it) const | StateSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateCgFxContainment() | StateSet |
invalidateIncarnation() | StateSet | [protected, virtual]
invalidateTransparencyContainment() | StateSet |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StateSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent() const | StateSet |
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const StateSet &rhs) | StateSet |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeAttribute(size_t attributeIndex, size_t passIndex=0, VariantKey key=0) | StateSet |
removeAttribute(const StateAttribute *attribute, size_t passIndex=0, VariantKey key=0) | StateSet |
removeAttributeByObjectCode(unsigned int objectCode, size_t passIndex=0, VariantKey key=0) | StateSet |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removePass(size_t passIndex, VariantKey key=0) | StateSet |
removeRef() const | RCObject | [inline]
removeVariant(VariantKey key) | StateSet |
replacePass(const StatePass *pass, size_t passIndex, VariantKey key=0) | StateSet |
replaceVariant(VariantKey key, const StateVariant *variant) | StateSet |
replaceVariantKey(VariantKey oldKey, VariantKey newKey) | StateSet |
setActiveVariantKey(VariantKey key) | StateSet |
setName(const std::string &name) | Object |
StateSet() | StateSet | [protected]
StateSet(const Object &rhs) | StateSet | [protected]
StateSet(const StateSet &rhs) | StateSet | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | StateSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateSet() | StateSet | [protected, virtual]
Generated on Fri Aug 4 08:38:42 2006 for NVSGSDK by NVIDIA


StateSetUnifyTraverser Class Reference

Traverser that unifies identical StateSets. More...

#include <StateSetUnifyTraverser.h>

Inheritance diagram for StateSetUnifyTraverser:

[legend]
Collaboration diagram for StateSetUnifyTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | StateSetUnifyTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~StateSetUnifyTraverser (void)
Protected destructor to prevent instantiation of a StateSetUnifyTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
Override of the doApply method.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Routine to handle a GeoNode 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 | 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 | handleTextureAttribute (const nvsg::TextureAttribute *p)
Routine to handle a TextureAttribute object while traversing the scene graph.

Detailed Description

Traverser that unifies identical StateSets.

Identical StateSets are recognized and linked to the same one. Identical StateAttributes are recognized and linked to the same one. This way, redundant objects are removed, thereby reducing storage space as well as run time.

Constructor & Destructor Documentation

NVSG_API StateSetUnifyTraverser ( void )

Constructor.

virtual NVSG_API ~StateSetUnifyTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a StateSetUnifyTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * scene ) [protected, virtual]

Override of the doApply method.

Parameters:
scene A pointer to the constant Scene to unify StateSet objects in.
Remarks:
The doApply method is the traversal entry point of a Traverser. The local data is cleared and OptimizeTraverser::doApply() is called to start traversal.
See also:
nvsg::Scene, Traverser

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode object while traversing the scene graph.

After traversing the GeoNode p, all StateSets used in this GeoNode are tested for equivalence with others. All StateSets that are equivalent to an other already encountered one are replaced by that.

Parameters:
p currently visited GeoNode object.

Reimplemented from Traverser.

virtual NVSG_API void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Routine to handle a StatePass object while traversing the scene graph.

After traversing the StatePass p, all StateAttributes used in this StatePass are tested for equivalence with others. All StateAttributes that are equivalent to an other already encountered one are replaced by that.

Parameters:
p currently visited StatePass object.

Reimplemented from Traverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Routine to handle a StateSet object while traversing the scene graph.

After traversing the StateSet p, all StateVariants used in this StateSet are tested for equivalence with others. All StateVariants that are equivalent to an other already encountered one are replaced by that.

Parameters:
p currently visited StateSet object.

Reimplemented from Traverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Routine to handle a StateVariant object while traversing the scene graph.

After traversing the StateVariant p, all StatePasses used in this StateVariant are tested for equivalence with others. All StatePasses that are equivalent to an other already encountered one are replaced by that.

Parameters:
p currently visited StateVariant object.

Reimplemented from Traverser.

virtual NVSG_API void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Routine to handle a TextureAttribute object while traversing the scene graph.

After traversing the TextureAttribute p, all TextureAttributeItems used in this TextureAttribute are tested for equivalence with others. All TextureAttributeItems that are equivalent to an other already encountered one are replaced by that.

Parameters:
p currently visited TextureAttribute object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • StateSetUnifyTraverser.h
Generated on Fri Aug 4 08:39:42 2006 for NVSGSDK by NVIDIA


Member List

StateSetUnifyTraverser Member List

This is the complete list of members for StateSetUnifyTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | StateSetUnifyTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | StateSetUnifyTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | StateSetUnifyTraverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | StateSetUnifyTraverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | StateSetUnifyTraverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | StateSetUnifyTraverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
StateSetUnifyTraverser(void) | StateSetUnifyTraverser |
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateSetUnifyTraverser(void) | StateSetUnifyTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:42 2006 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

virtual NVSG_API const StateVariant * | clone () const
Create a new StateVariant by copying from this.

NVSG_API size_t | getNumberOfOwners () const
Get the number of owners of this StateVariant.

NVSG_API const StateSet * | getOwner (size_t index) const
Get a pointer to the constant owning StateSet at position index.

NVSG_API size_t | getNumberOfPasses () const
Get the number of StatePass objects in this StateVariant.

NVSG_API const StatePass * | getPass (size_t index) const
Get the StatePass at the specified position.

NVSG_API void | addPass (const StatePass *pass)
Add a StatePass to this StateVariant.

NVSG_API void | removePass (size_t passIndex)
Remove the StatePass at the specified position.

NVSG_API void | replacePass (const StatePass *pass, size_t index)
Replace the StatePass at the specified position.

NVSG_API size_t | getNumberOfAttributes (size_t passIndex=0) const
Get the number of StateAttribute objects in the specified StatePass.

NVSG_API const StateAttribute * | getAttribute (size_t attributeIndex, size_t passIndex=0) const
Get the StateAttribute at the specified position.

NVSG_API const StateAttribute * | getAttributeByObjectCode (unsigned int objectCode, size_t passIndex=0) const
Get the StateAttribute with the object code objectCode in the specified StatePass.

NVSG_API size_t | getAttributeIndex (const StateAttribute *attribute, size_t passIndex=0) const
Get the index of the StateAttribute in the specified StatePass.

NVSG_API void | addAttribute (const StateAttribute *attribute, size_t passIndex=0)
Add a StateAttribute to the specified StatePass.

NVSG_API void | removeAttribute (size_t attributeIndex, size_t passIndex=0)
Remove the StateAttribute at the specified position.

NVSG_API void | removeAttribute (const StateAttribute *attribute, size_t passIndex=0)
Remove the given StateAttribute from the specified StatePass.

NVSG_API void | removeAttributeByObjectCode (unsigned int objectCode, size_t 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.

Static Public Member Functions

NVSG_API const StateVariant * | create ()
Create a StateVariant.

NVSG_API const StateVariant * | createFromBase (const Object &rhs)
Create a StateVariant by copying from an Object.

Protected Member Functions

NVSG_API | StateVariant ()
Protected default constructor to prevent explicit creation.

NVSG_API | StateVariant (const Object &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | StateVariant (const StateVariant &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~StateVariant ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | invalidateIncarnation ()
Invalidate the nvutil::Incarnation.

virtual NVSG_API void | validateIncarnation () const
Validate the Incarnation.

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 ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside StateVariant::create.

NVSG_API StateVariant ( const Object & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Object to use as a base of the new StateVariant.
Remarks:
This constructor is never used explicitly, but only inside StateVariant::createFromBase.
See also:
Object

NVSG_API StateVariant ( const StateVariant & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StateVariant to copy from
Remarks:
This constructor is never used explicitly, but only inside StateVariant::create.

virtual NVSG_API ~StateVariant ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the StateVariant is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const StateVariant* create ( ) [static]

Create a StateVariant.

Returns:
A pointer to a constant StateVariant.
Remarks:
An empty StateVariant is created.
See also:
Object

NVSG_API const StateVariant* createFromBase ( const Object & rhs ) [static]

Create a StateVariant by copying from an Object.

Parameters:
rhs A reference to the constant StateVariant to copy from.
Returns:
A pointer to a constant StateVariant.
Remarks:
All the data from the Object rhs is used as the base information for the newly created StateVariant. The created StateVariant then is empty.
See also:
Object

virtual NVSG_API const StateVariant* clone ( ) const [virtual]

Create a new StateVariant by copying from this.

Returns:
A pointer to a constant StateVariant.
Remarks:
The newly created StateVariant is an exact copy of this.

size_t getNumberOfOwners ( ) const [inline]

Get the number of owners of this StateVariant.

Returns:
The number of owners of this StateVariant.
See also:
StateSet, getOwner

const StateSet * getOwner ( size_t index ) const [inline]

Get a pointer to the constant owning StateSet at position index.

Parameters:
index The index of the StateSet to get.
Returns:
A pointer to the constant owning StateSet at position index.
Note:
The behavior is undefined if index is larger than or equal to the number of owners of this StateVariant.
See also:
StateSet, getNumberOfOwners

size_t 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

const StatePass * getPass ( size_t 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 ( const StatePass * 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 ( size_t 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 | ( | const StatePass * | pass,
 |  | size_t | 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

size_t getNumberOfAttributes ( size_t 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

const StateAttribute * getAttribute | ( | size_t | attributeIndex,
 |  | size_t | 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

const StateAttribute * getAttributeByObjectCode | ( | unsigned int | objectCode,
 |  | size_t | 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

size_t getAttributeIndex | ( | const StateAttribute * | attribute,
 |  | size_t | 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 | ( | const StateAttribute * | attribute,
 |  | size_t | 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 | ( | size_t | attributeIndex,
 |  | size_t | 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 | ( | const StateAttribute * | attribute,
 |  | size_t | 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,
 |  | size_t | 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 Object. Then any StatePass attached to this StateVariant is removed, and all StatePass objects of rhs are copied.
See also:
Object, 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 void invalidateIncarnation ( ) [protected, virtual]

Invalidate the nvutil::Incarnation.

Remarks:
This function is called from the framework when the nvutil::Incarnation of this StatePass has increased and now is to be marked as invalid. It first increases the nvutil::Incarnation of all its owners, then its own nvutil::Incarnation is marked as invalid.
See also:
nvutil::Incarnation, validateIncarnation

Reimplemented from Object.

virtual NVSG_API void validateIncarnation ( ) const [protected, 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.

The documentation for this class was generated from the following file:
  • StateVariant.h
Generated on Fri Aug 4 08:38:43 2006 for NVSGSDK by NVIDIA


Member List

StateVariant Member List

This is the complete list of members for StateVariant, including all inherited members.
addAttribute(const StateAttribute *attribute, size_t passIndex=0) | StateVariant |
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addPass(const StatePass *pass) | StateVariant |
addRef() const | RCObject | [inline]
clone() const | StateVariant | [virtual]
containsCgFx() const | StateVariant |
create() | StateVariant | [static]
createFromBase(const Object &rhs) | StateVariant | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAttribute(size_t attributeIndex, size_t passIndex=0) const | StateVariant | [inline]
getAttributeByObjectCode(unsigned int objectCode, size_t passIndex=0) const | StateVariant | [inline]
getAttributeIndex(const StateAttribute *attribute, size_t passIndex=0) const | StateVariant | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfAttributes(size_t passIndex=0) const | StateVariant | [inline]
getNumberOfOwners() const | StateVariant | [inline]
getNumberOfPasses() const | StateVariant | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | StateVariant | [inline]
getPass(size_t index) const | StateVariant | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateCgFxContainment() | StateVariant |
invalidateIncarnation() | StateVariant | [protected, virtual]
invalidateTransparencyContainment() | StateVariant |
isDataShared() const | Object | [virtual]
isEachPassTransparent() const | StateVariant |
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StateVariant | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent() const | StateVariant |
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const StateVariant &rhs) | StateVariant |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeAttribute(size_t attributeIndex, size_t passIndex=0) | StateVariant | [inline]
removeAttribute(const StateAttribute *attribute, size_t passIndex=0) | StateVariant | [inline]
removeAttributeByObjectCode(unsigned int objectCode, size_t passIndex) | StateVariant | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removePass(size_t passIndex) | StateVariant |
removeRef() const | RCObject | [inline]
replacePass(const StatePass *pass, size_t index) | StateVariant |
setName(const std::string &name) | Object |
StateVariant() | StateVariant | [protected]
StateVariant(const Object &rhs) | StateVariant | [protected]
StateVariant(const StateVariant &rhs) | StateVariant | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
validateIncarnation() const | StateVariant | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateVariant() | StateVariant | [protected, virtual]
Generated on Fri Aug 4 08:38:43 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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 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 size_t | 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, size_t numStrips)
Set the strips of this StrippedPrimitiveSet.

NVSG_API void | setStrips (size_t pos, const IndexSet *strips, size_t numStrips)
Set a subset of strips of this StrippedPrimitiveSet.

virtual NVSG_API const StrippedPrimitiveSet * | clone (void) const=0
Interface for creating a new StrippedPrimitiveSet by copying from this.

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 | ~StrippedPrimitiveSet (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere (void) 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

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.

virtual NVSG_API ~StrippedPrimitiveSet ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the StrippedPrimitiveSet is decremented to zero.
See also:
addRef, removeRef

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

size_t 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,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const IndexSet * | strips,
 |  | size_t | 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 const StrippedPrimitiveSet* clone ( void ) const [pure virtual]

Interface for creating a new StrippedPrimitiveSet by copying from this.

Returns:
A pointer to a constant StrippedPrimitiveSet.
Remarks:
The newly created StrippedPrimitiveSet is an exact copy of this.

Implements PrimitiveSet.

Implemented in LineStrips, QuadStrips, TriFans, and TriStrips.

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::Sphere3f calculateBoundingSphere ( void ) 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.

Reimplemented from PrimitiveSet.

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 Fri Aug 4 08:38:45 2006 for NVSGSDK by NVIDIA


Member List

StrippedPrimitiveSet Member List

This is the complete list of members for StrippedPrimitiveSet, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere(void) const | StrippedPrimitiveSet | [protected, virtual]
clone(void) const=0 | StrippedPrimitiveSet | [pure virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
getBoundingSphere(void) const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
nvsg::PrimitiveSet::operator=(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
nvsg::Drawable::operator=(const Drawable &rhs) | Drawable | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setStrips(const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setStrips(size_t pos, const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
theAllocator typedef | IAllocator |
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected, virtual]
Generated on Fri Aug 4 08:38:45 2006 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 (size_t &triStripLength, size_t &quadStripLength) const
Get the minimal lengths for TriStrips and QuadStrips.

void | setMinimalLengths (size_t triStripLength, size_t 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 (const 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 (const nvsg::Quads *p)
Hold the Quads to strip in handleGeoNode.

virtual NVSG_API void | handleTriangles (const nvsg::Triangles *p)
Hold the Triangles to strip in handleGeoNode.

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 | ( | size_t & | triStripLength,
 |  | size_t & | 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 | ( | size_t | triStripLength,
 |  | size_t | 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 ( const nvsg::GeoNode * p ) [protected, virtual]

Convert each Quads to a QuadStrips and a Quads, and each Triangles to a TriStrips and a Triangles.

Parameters:
p GeoNode to handle

Reimplemented from Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Hold the Quads to strip in handleGeoNode.

Parameters:
p Quads to strip

Reimplemented from Traverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Hold the Triangles to strip in handleGeoNode.

Parameters:
p Triangles to strip

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • StrippingTraverser.h
Generated on Fri Aug 4 08:39:43 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | Traverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getMinimalLengths(size_t &triStripLength, size_t &quadStripLength) const | StrippingTraverser | [inline]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | StrippingTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | StrippingTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | StrippingTraverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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(size_t triStripLength, size_t quadStripLength) | StrippingTraverser | [inline]
StrippingTraverser(void) | StrippingTraverser |
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippingTraverser(void) | StrippingTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:43 2006 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 Member Functions

virtual NVSG_API const Switch * | clone () const
Create a new Switch by copying from this.

NVSG_API void | setActive ()
Set all children of this Switch active.

NVSG_API void | setActive (size_t index)
Make the specified child of the Switch to active.

NVSG_API void | setInactive ()
Set all children of the Switch to inactive.

NVSG_API void | setInactive (size_t index)
Make the specified child of the Switch to inactive.

NVSG_API size_t | getNumberOfActive () const
Get the number of active children.

NVSG_API size_t | getActive (std::vector< size_t > &indices) const
Get indices to active child nodes.

NVSG_API bool | isActive () const
Test if any of the children is active.

NVSG_API bool | isActive (size_t 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.

Static Public Member Functions

NVSG_API const Switch * | create ()
Create a Switch.

NVSG_API const Switch * | createFromBase (const Group &rhs)
Create a Switch by copying from a Group.

Protected Member Functions

NVSG_API | Switch ()
Protected default constructor to prevent explicit creation.

NVSG_API | Switch (const Group &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Switch (const Switch &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Switch ()
Protected destructor to prevent explicit creation.

virtual NVSG_API void | postRemoveChild (size_t index)
Called from the framework immediately after a child has been removed from the Switch.

virtual NVSG_API void | postAddChild (size_t index)
Called from the framework immediately after a child was added to the 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 (void) const
Called from the framework if re-determination of the transparency containment cache is required.

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.
Example
                 sw
                 |
     -----------------------
     |      |       |      |
     c0     c1      c2     c3

  [...]
  sw->setInactive();  // set all children inactive
  sw->setActive(0);   // set child c0 active
  sw->setActive(3);   // set child c3 active
  [...]
In this sample only C0 and C3 will be active and traversed.

Constructor & Destructor Documentation

NVSG_API Switch ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Switch::create.

NVSG_API Switch ( const Group & rhs ) [explicit, protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Group to use as a base of the new Switch
Remarks:
This constructor is never used explicitly, but only inside Switch::createFromBase. Per default no child is active.
See also:
Group

NVSG_API Switch ( const Switch & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Switch to copy from
Remarks:
This constructor is never used explicitly, but only inside Switch::create.

virtual NVSG_API ~Switch ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the LineAttribute is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Switch* create ( ) [static]

Create a Switch.

Returns:
A pointer to a constant Switch.
Remarks:
Per default a Switch is empty and no child is active.

Reimplemented from Group.

NVSG_API const Switch* createFromBase ( const Group & rhs ) [static]

Create a Switch by copying from a Group.

Parameters:
rhs A reference to the constant Group to copy from.
Returns:
A pointer to a constant Switch.
Remarks:
All the data from the Group rhs is used as the base information for the newly created Switch. By default no child is active.
See also:
Group

virtual NVSG_API const Switch* clone ( ) const [virtual]

Create a new Switch by copying from this.

Returns:
A pointer to a constant Switch.
Remarks:
The newly created Switch is an exact copy of this.

Reimplemented from Group.

NVSG_API void setActive ( )

Set all children of this Switch active.

Remarks:
Make all children visible so all traversers traverse them.
See also:
setInactive

NVSG_API void setActive ( size_t index )

Make the specified child of the Switch to 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 so all traversers traverse it.
Currently active children will stay active.
See also:
setInactive

NVSG_API void setInactive ( )

Set all children of the Switch to inactive.

Remarks:
Make all children invisible so no traverser traverses them.
See also:
setActive, isActive

NVSG_API void setInactive ( size_t index )

Make the specified child of the Switch to 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 so no traverser traverses it.
Currently inactive children will stay inactive.
See also:
setInactive, isActive

NVSG_API size_t getNumberOfActive ( ) const

Get the number of active children.

Returns:
Number of active children.
Remarks:
This function determines the number of currently active children under this Switch.
See also:
setActive, setInactive, isActive

NVSG_API size_t getActive ( std::vector< size_t > & 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 to the vector /a indices.
The internal format a Switch uses for storing indices is size_t, 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 is 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.
See also:
setActive, setInactive, isActive

NVSG_API bool isActive ( size_t 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.
Remarks:
This function can be used to test if a specific child is active.
See also:
setActive, 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 reference to the constant 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.

virtual NVSG_API void postRemoveChild ( size_t 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.
See also:
Group::postRemoveChild

Reimplemented from Group.

virtual NVSG_API void postAddChild ( size_t 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.
See also:
Group::postAddChild

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 containsHints is called while the hint containment flags mark that information as invalid.
See also:
containsHints, invalidateHintsContainment

Reimplemented from Group.

virtual NVSG_API bool determineTransparencyContainment ( void ) 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.

The documentation for this class was generated from the following file:
  • Switch.h
Generated on Fri Aug 4 08:38:46 2006 for NVSGSDK by NVIDIA


Member List

Switch Member List

This is the complete list of members for Switch, including all inherited members.
activateClipPlane(size_t index) | Group | [inline]
addChild(const Node *child, size_t position=0xFFFFFFFF) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere(void) const | Switch | [protected, virtual]
clone() const | Switch | [virtual]
containsCgFx() const | Group | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Group | [virtual]
containsTransparentGeometry() const | Node |
create() | Switch | [static]
createFromBase(const Group &rhs) | Switch | [static]
nvsg::Group::createFromBase(const Node &rhs) | Group | [static]
deactivateClipPlane(size_t index) | Group | [inline]
determineHintsContainment(unsigned short hints) const | Switch | [protected, virtual]
determineTransparencyContainment(void) const | Switch | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getActive(std::vector< size_t > &indices) const | Switch |
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getChild(size_t position) const | Group | [inline]
getChildPositions(const Node *node, std::vector< size_t > &positions) const | Group |
getClipPlane(size_t index) const | Group | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfActive() const | Switch |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfFrames() const | Group | [virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
Group() | Group | [protected]
Group(const Node &rhs) | Group | [explicit, protected]
Group(const Group &rhs) | Group | [protected]
hasChild(const Node *node) const | Group |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const Node *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Group | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Group | [virtual]
invalidateNumberOfFrames() const | Group | [virtual]
invalidateTransparencyContainment() | Node |
isActive() const | Switch |
isActive(size_t index) const | Switch |
isClipPlaneActive(size_t index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Switch | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
postAddChild(size_t index) | Switch | [protected, virtual]
postRemoveChild(size_t index) | Switch | [protected, virtual]
preAddChild(size_t position) | Group | [protected, virtual]
preRemoveChild(size_t position) | Group | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeChild(const Node *child) | Group |
removeChild(size_t position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceChild(const Node *newChild, const Node *oldChild) | Group |
replaceChild(const Node *newChild, size_t position) | Group |
setActive() | Switch |
setActive(size_t index) | Switch |
setAnnotation(const std::string &anno) | Node |
setClipPlane(size_t index, const nvmath::Plane3f &plane) | Group | [inline]
setHints(unsigned short hints) | Node | [inline]
setInactive() | Switch |
setInactive(size_t index) | Switch |
setName(const std::string &name) | Object |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
Switch() | Switch | [protected]
Switch(const Group &rhs) | Switch | [explicit, protected]
Switch(const Switch &rhs) | Switch | [protected]
theAllocator typedef | IAllocator |
validateIncarnation() const | Group | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Group() | Group | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Switch() | Switch | [protected, virtual]
Generated on Fri Aug 4 08:38:46 2006 for NVSGSDK by NVIDIA


SwitchToGroupTraverser Class Reference

Traverser that replaces Switch objects by Group objects holding the active children only. More...

#include <SwitchToGroupTraverser.h>

Inheritance diagram for SwitchToGroupTraverser:

[legend]
Collaboration diagram for SwitchToGroupTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | SwitchToGroupTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~SwitchToGroupTraverser (void)
Protected destructor to prevent instantiation of an SwitchToGroupTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
If the root node is a Switch, it is replaced by a Group.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Replace all Switch objects beneath that Transform to a Group objects.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Replace all Switch objects beneath that Billboard to Group objects.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Replace all Switch objects beneath that Group to Group objects.

virtual NVSG_API void | handleLOD (const nvsg::LOD *p)
Replace all Switch objects beneath that LOD to Group objects.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Replace all Switch objects beneath that Transform to Group objects.

Detailed Description

Traverser that replaces Switch objects by Group objects holding the active children only.

Constructor & Destructor Documentation

NVSG_API SwitchToGroupTraverser ( void )

Constructor.

virtual NVSG_API ~SwitchToGroupTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of an SwitchToGroupTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * scene ) [protected, virtual]

If the root node is a Switch, it is replaced by a Group.

Parameters:
scene scene that holds tree to be optimized

Reimplemented from OptimizeTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Replace all Switch objects beneath that Transform to a Group objects.

An AnimatedTransform is handled as a Transform.h

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Replace all Switch objects beneath that Billboard to Group objects.

Parameters:
p points to the currently visited Billboard

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Replace all Switch objects beneath that Group to Group objects.

Parameters:
p points to the currently visited Group

Reimplemented from Traverser.

virtual NVSG_API void handleLOD ( const nvsg::LOD * p ) [protected, virtual]

Replace all Switch objects beneath that LOD to Group objects.

Parameters:
p points to the currently visited LOD

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Replace all Switch objects beneath that Transform to Group objects.

Parameters:
p points to the currently visited Transform

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • SwitchToGroupTraverser.h
Generated on Fri Aug 4 08:39:44 2006 for NVSGSDK by NVIDIA


Member List

SwitchToGroupTraverser Member List

This is the complete list of members for SwitchToGroupTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | SwitchToGroupTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | SwitchToGroupTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | SwitchToGroupTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | SwitchToGroupTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | SwitchToGroupTraverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | SwitchToGroupTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
SwitchToGroupTraverser(void) | SwitchToGroupTraverser |
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~SwitchToGroupTraverser(void) | SwitchToGroupTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:44 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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 Fri Aug 4 08:37:06 2006 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 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 bpp
Specifies the number of bytes per pixel.

uint_t bps
Specifies the number of bytes per scanline.

uint_t bpi
Specifies the number of bytes per image (slice).

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 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 bpp

Specifies the number of bytes per pixel.

uint_t bps

Specifies the number of bytes per scanline.

uint_t bpi

Specifies the number of bytes per image (slice).

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 Fri Aug 4 08:37:07 2006 for NVSGSDK by NVIDIA


Member List

texImage_t Member List

This is the complete list of members for texImage_t, including all inherited members.
bpi | texImage_t
bpp | texImage_t
bps | texImage_t
dataType | texImage_t
depth | texImage_t
file | texImage_t
flags | texImage_t
height | texImage_t
pixelFormat | texImage_t
pixels | texImage_t
width | texImage_t
Generated on Fri Aug 4 08:37:07 2006 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 = 0xFFFFFFFF }

Public Member Functions

virtual NVSG_API const TextureAttribute * | clone (void) const
Get a clone of this texture attribute.

NVSG_API void | bindTextureAttributeItem (const TextureAttributeItem *item, size_t unit)
Bind texture attribute item.

NVSG_API void | unbindTextureAttributeItem (size_t unit)
Unbind texture attribute item.

NVSG_API size_t | getFirstItem (void) const
Get first item.

NVSG_API size_t | getNextItem (void) const
Get next item.

NVSG_API size_t | getNumberOfItems (void) const
Get number of item.

NVSG_API const TextureAttributeItem * | getTextureAttributeItem (size_t unit) const
Get texture attribute item.

NVSG_API TextureAttribute & | operator= (const TextureAttribute &rhs)
Deep copy.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other TextureAttribute.

Static Public Member Functions

NVSG_API const TextureAttribute * | create (void)
Create a TextureAttribute.

NVSG_API const TextureAttribute * | createFromBase (const StateAttribute &rhs)
Create a TextureAttribute by copying from a StateAttribute.

Protected Member Functions

NVSG_API | TextureAttribute (void)
Default Constructor.

NVSG_API | TextureAttribute (const StateAttribute &rhs)
Partial Constructor.

NVSG_API | TextureAttribute (const TextureAttribute &rhs)
Copy constructor.

virtual NVSG_API | ~TextureAttribute (void)
Protected destructor to prevent explicit creation on stack.

virtual NVSG_API void | validateIncarnation (void) const
Marks 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.

Constructor & Destructor Documentation

NVSG_API TextureAttribute ( void ) [protected]

Default Constructor.

NVSG_API TextureAttribute ( const StateAttribute & rhs ) [protected]

Partial Constructor.

NVSG_API TextureAttribute ( const TextureAttribute & rhs ) [protected]

Copy constructor.

virtual NVSG_API ~TextureAttribute ( void ) [protected, virtual]

Protected destructor to prevent explicit creation on stack.

Member Function Documentation

NVSG_API const TextureAttribute* create ( void ) [static]

Create a TextureAttribute.

Returns:
a constant pointer to a TextureAttribute.

NVSG_API const TextureAttribute* createFromBase ( const StateAttribute & rhs ) [static]

Create a TextureAttribute by copying from a StateAttribute.

Returns:
a constant pointer to a TextureAttribute.

virtual NVSG_API const TextureAttribute* clone ( void ) const [virtual]

Get a clone of this texture attribute.

Returns:
a constant pointer to a TextureAttribute.

Implements StateAttribute.

NVSG_API void bindTextureAttributeItem | ( | const TextureAttributeItem * | item,
 |  | size_t | unit
 | ) |

Bind texture attribute item.

This binds the texture attribute item pointed to by item to the texture unit specified by unit. A texture attribute that was bound to that texture unit prior to this call, will be unbound.

Parameters:
item | Texture attribute item to be bound.
unit | Zero based index of the texture unit the item should be bound to.

NVSG_API void unbindTextureAttributeItem ( size_t unit )

Unbind texture attribute item.

Unbind the texture attribute item currently bound to the texture unit specified by unit. Immediately after this call, no texture attribute item is bound to that unit.

Parameters:
unit Zero based index of the texture unit.

size_t getFirstItem ( void ) const [inline]

Get first item.

This is thought to initiate iteration of bounded texture attribute items. Use this in conjunction with getNextItem to iterate over all bounded texture attribute items.

Returns:
The zero based index of the first texture unit a texture attribute item is actually bound to or INVALID_ITEM if no texture attribute item is currently bound.

size_t getNextItem ( void ) const [inline]

Get next item.

This is thought to pursue iteration of bounded texture attribute items.

Note:
An iteration must be started by a call to getFirstItem to ensure that the iteration starts at the very first texture unit a texture attribute item is actually bound to.
Returns:
The zero based index of the very next texture unit a texture attribute item is actually bound to or INVALID_ITEM if no further texture attribute item is currently bound.

size_t getNumberOfItems ( void ) const [inline]

Get number of item.

Returns:
The number of texture attribute items currently bound.
Note:
Do not use this to iterate through the items. If you want to iterate use this construct:
 for ( size_t tu = pAttrib->getFirstItem()
     ; tu != TextureAttribute::INVALID_ITEM
     ; tu = pAttrib->getNextItem())
 {
 }

const TextureAttributeItem * getTextureAttributeItem ( size_t unit ) const [inline]

Get texture attribute item.

Returns:
The texture attribute item that is currently bound to the texture unit specified by unit or a null pointer if no texture attribute item is currently bound to texture unit unit.
Parameters:
unit Zero based index of queried texture unit.

NVSG_API TextureAttribute& operator= ( const TextureAttribute & rhs )

Deep copy.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other TextureAttribute.

Returns:
true if the TextureAttribute p is equivalent to this TextureAttribute.
Parameters:
p | TextureAttribute to test for equivalence with
ignoreNames | are the names to be ignored?
deepCompare | deep compare?

Reimplemented from Object.

virtual NVSG_API void validateIncarnation ( void ) const [protected, virtual]

Marks the Incarnation of this Object as valid.

Remarks:
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:
Object::invalidateIncarnation

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • TextureAttribute.h
Generated on Fri Aug 4 08:38:49 2006 for NVSGSDK by NVIDIA


Member List

TextureAttribute Member List

This is the complete list of members for TextureAttribute, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
bindTextureAttributeItem(const TextureAttributeItem *item, size_t unit) | TextureAttribute |
clone(void) const | TextureAttribute | [virtual]
create(void) | TextureAttribute | [static]
createFromBase(const StateAttribute &rhs) | TextureAttribute | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFirstItem(void) const | TextureAttribute | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNextItem(void) const | TextureAttribute | [inline]
getNumberOfItems(void) const | TextureAttribute | [inline]
getNumberOfParents(void) const | StateAttribute | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | StateAttribute | [inline]
getTextureAttributeItem(size_t unit) const | TextureAttribute | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
INVALID_ITEM enum value (defined in TextureAttribute) | TextureAttribute |
invalidateIncarnation(void) | StateAttribute | [protected, virtual]
invalidateTransparencyContainment(void) | StateAttribute |
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | TextureAttribute | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isTransparent(void) const | StateAttribute | [virtual]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const TextureAttribute &rhs) | TextureAttribute |
nvsg::StateAttribute::operator=(const StateAttribute &rhs) | StateAttribute | [protected]
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
StateAttribute(void) | StateAttribute | [protected]
StateAttribute(const StateAttribute &rhs) | StateAttribute | [protected]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
TextureAttribute(void) | TextureAttribute | [protected]
TextureAttribute(const StateAttribute &rhs) | TextureAttribute | [protected]
TextureAttribute(const TextureAttribute &rhs) | TextureAttribute | [protected]
theAllocator typedef | IAllocator |
unbindTextureAttributeItem(size_t unit) | TextureAttribute |
validateIncarnation(void) const | TextureAttribute | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StateAttribute(void) | StateAttribute | [protected, virtual]
~TextureAttribute(void) | TextureAttribute | [protected, virtual]
Generated on Fri Aug 4 08:38:49 2006 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

virtual NVSG_API const TextureAttributeItem * | clone (void) const
Returns a clone of this 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 bool | getTextureFileName (std::string &filename) const
Initializes filename with the name of the currently associated texture file.

NVSG_API const std::string & | getTextureFileName () const
Returns the filename of the currently associated texture file.

NVSG_API const TextureImage * | getTextureImage () const
Returns the currently associated texture image.

NVSG_API const TextureImage * | reloadTextureImage () const
Reloads the TextureImage from the currently specified texture file.

NVSG_API void | setTextureImageSpec (const std::string &filename, const TextureImage *texImg=NULL)
Specifies the texture image that you want to associate with this TextureAttributeItem.

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
Get 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 TextureMagFilterMode | getMagFilterMode (void) const
Returns the actual used magnifying filter mode for this TextureAttributeItem.

NVSG_API void | setMagFilterMode (TextureMagFilterMode mode)
Sets the magnifying filter mode to be used with this TextureAttributeItem.

NVSG_API TextureMinFilterMode | getMinFilterMode (void) const
Returns the actual minifying filter mode used this this TextureAttributeItem.

NVSG_API void | setMinFilterMode (TextureMinFilterMode mode)
Sets the minifying filter mode to be used with this TextureAttributeItem.

NVSG_API TextureWrapMode | getWrapMode (TexWrapCoordAxis target) const
Returns the actual wrap parameter for the specified texture coordinates used with this TextureAttributeItem.

NVSG_API void | setWrapMode (TexWrapCoordAxis target, TextureWrapMode mode)
Sets the wrap parameter for the specified texture coordinates.

NVSG_API nvmath::Mat44f | getMatrix (void) const
Returns the actual texture matrix used to transform the texture during rendering.

NVSG_API const nvmath::Quatf & | getOrientation (void) const
Returns the rotational part of the actual texture matrix used to transform the texture during rendering.

NVSG_API void | setOrientation (const nvmath::Quatf &orientation)
Sets the rotational part of the texture matrix used to transform the texture during rendering.

NVSG_API const nvmath::Vec3f & | getScaling (void) const
Returns the scaling part of the actual texture matrix used to transform the texture during rendering.

NVSG_API void | setScaling (const nvmath::Vec3f &scale)
Sets the scaling part of the texture matrix used to transform the texture during rendering.

NVSG_API const nvmath::Vec3f & | getTranslation (void) const
Returns the translational part of the actual texture matrix used to transform the texture during rendering.

NVSG_API void | setTranslation (const nvmath::Vec3f &trans)
Sets the translational part of the texture matrix used to transform the texture during rendering.

NVSG_API bool | isLoadable () const
Returns whether the associated texture image could be loaded successfully.

NVSG_API void | setTexGenMode (TexCoordAxis axis, TexGenMode mode)
Sets the texture generation mode for the specified coordinate axis.

NVSG_API TexGenMode | getTexGenMode (TexCoordAxis axis) const
Returns the texture coordinate generation mode for the specified coordinate axis.

NVSG_API void | setTexGenLinearPlane (TexCoordAxis axis, TexGenLinearPlane target, const nvmath::Vec4f &plane)
Sets the plane to be used for linear texture generation.

NVSG_API const nvmath::Vec4f & | getTexGenLinearPlane (TexCoordAxis axis, TexGenLinearPlane plane) const
Returns the base plane for linear texture coordinate generation.

NVSG_API TextureAttributeItem & | operator= (const TextureAttributeItem &rhs)
Assignement operator.

NVSG_API size_t | getNumberOfOwners () const
Returns the number of texture attributes that own this item.

NVSG_API const TextureAttribute * | getOwner (size_t index) const
Returns the owning texture attribute at the specified zero-based index.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other TextureAttributeItem.

Static Public Member Functions

NVSG_API const TextureAttributeItem * | create (void)
Instantiates a TextureAttributeItem object.

NVSG_API const TextureAttributeItem * | createFromBase (const Object &rhs)
Instantiates a TextureAttributeItem object.

Protected Member Functions

NVSG_API | TextureAttributeItem (void)
This constructor is called when instantiating a default TextureAttributeItem.

NVSG_API | TextureAttributeItem (const Object &rhs)
This constructor is called when instantiating a TextureAttributeItem from a certain base class object.

NVSG_API | TextureAttributeItem (const TextureAttributeItem &rhs)
This copy constructor is called when instantiating a TextureAttributeItem from another TextureAttributeItem object.

virtual NVSG_API | ~TextureAttributeItem ()
The destructor is called when deleting a TextureAttributeItem object.

virtual NVSG_API void | invalidateIncarnation (void)
Invalidate the Incarnation.

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 ) [protected]

This constructor is called when instantiating a default TextureAttributeItem.

NVSG_API TextureAttributeItem ( const Object & rhs ) [protected]

This constructor is called when instantiating a TextureAttributeItem from a certain base class object.

NVSG_API TextureAttributeItem ( const TextureAttributeItem & rhs ) [protected]

This copy constructor is called when instantiating a TextureAttributeItem from another TextureAttributeItem object.

virtual NVSG_API ~TextureAttributeItem ( ) [protected, virtual]

The destructor is called when deleting a TextureAttributeItem object.

A TextureAttributeItem will be automatically deleted if its reference count changes from 1 to 0, after a call to removeRef.

Member Function Documentation

NVSG_API const TextureAttributeItem* create ( void ) [static]

Instantiates a TextureAttributeItem object.

Returns:
A pointer to a const TextureAttributeItem object.

NVSG_API const TextureAttributeItem* createFromBase ( const Object & rhs ) [static]

Instantiates a TextureAttributeItem object.

The function instantiates a TextureAttributeItem object and copies the Object part from rhs.

Returns:
A pointer to a const TextureAttributeItem object.

virtual NVSG_API const TextureAttributeItem* clone ( void ) const [virtual]

Returns a clone of this textureAttributeItem.

Returns:
A pointer to a const TextureAttributeItem object.

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.

bool getTextureFileName ( std::string & filename ) const [inline]

Initializes filename with the name of the currently associated texture file.

Returns:
true if a texture file is currently associated, false otherwise.
Parameters:
filename Receive the filename of the associated texture file here.

const std::string & getTextureFileName ( ) const [inline]

Returns the filename of the currently associated texture file.

Use setTextureImageSpec to associate a texture file with this TextureAttributeItem.

Returns:
The filename of the currently associated texture file.

const TextureImage * getTextureImage ( ) const [inline]

Returns the currently associated texture image.

Use setTextureImageSpec to associate a texture image with this TextureAttributeItem. /**

Returns:
A pointer to the const TextureImage that was associated through a call to setTextureImageSpec.

NVSG_API const TextureImage* reloadTextureImage ( ) const

Reloads the TextureImage from the currently specified texture file.

For this function to succeed it is required that a texture file previously was specified through a call to setTextureImageSpec.

Returns:
A pointer to the reloaded TextureImage if successful. Otherwise the function returns a NULL pointer.

NVSG_API void setTextureImageSpec | ( | const std::string & | filename,
 |  | const TextureImage * | texImg = NULL
 | ) |

Specifies the texture image that you want to associate with this TextureAttributeItem.

A texture image can be specified by either a texture file from which the image can be loaded, or a pre-created TextureImage object, or both.

Usually a texture image is stored in a file. In this case you can omit the second parameter. Passing a valid filename as first parameter will do. The texture image than will be created from the specified file during the first rendering.

However, in some cases it might be not desired to provide a filename but to pass as second argument a pointer to a TextureImage object, that could have been pre-created from e.g. a RBGA lump, or from a file that you don't want to communicate. If you don't want to communicate a filename simply pass an empty string as first parameter.

Parameters:
filename | Specifies the name of the texture file .
texImg | Specifies the TextureImage object.

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.

void setBorderColor ( const nvmath::Vec4f & color ) [inline]

Sets the border color to be used with this TextureAttributeItem.

Parameters:
color Specifies the RGBA color value to be used as the border color.

const nvmath::Vec4f & getEnvColor ( void ) const [inline]

Get the actual environment color of this TextureAttributeItem.

Returns:
A reference to the constant 4-component vector (RGBA) specifying the actual environment color to be used.
See also:
setEnvColor

void setEnvColor ( const nvmath::Vec4f & color ) [inline]

Sets the environment color to be used with this TextureAttributeItem.

Parameters:
color A reference to a constant 4-component vector (RGBA) to be used as the environment color.
See also:
getEnvColor

TextureEnvMode getEnvMode ( void ) const [inline]

Returns the actual used environment mode for this TextureAttributeItem.

Returns:
A TextureEnvMode enum specifying the actual environment mode.

void setEnvMode ( TextureEnvMode mode ) [inline]

Sets the environment mode to be used with this TextureAttributeItem.

Parameters:
mode Specifies the environment mode.

TextureMagFilterMode getMagFilterMode ( void ) const [inline]

Returns the actual used magnifying filter mode for this TextureAttributeItem.

Returns:
A TextureMagFilterMode enum specifying the actual magnifying filter mode.

void setMagFilterMode ( TextureMagFilterMode mode ) [inline]

Sets the magnifying filter mode to be used with this TextureAttributeItem.

Parameters:
mode Specifies the filter mode.

TextureMinFilterMode getMinFilterMode ( void ) const [inline]

Returns the actual minifying filter mode used this this TextureAttributeItem.

Returns:
A TextureMinFilterMode enum specifying the actual minifying filter mode.

NVSG_API void setMinFilterMode ( TextureMinFilterMode mode )

Sets the minifying filter mode to be used with this TextureAttributeItem.

Parameters:
mode Specifies the filter mode.

TextureWrapMode getWrapMode ( TexWrapCoordAxis target ) const [inline]

Returns the actual wrap parameter for the specified texture coordinates used with this TextureAttributeItem.

Returns:
A TextureWrapMode enum specifying the actual wrap parameter.
Parameters:
target Specifies the texture coordinates for which to query the wrap parameter.

void setWrapMode | ( | TexWrapCoordAxis | target,
 |  | TextureWrapMode | mode
 | ) | [inline]

Sets the wrap parameter for the specified texture coordinates.

The function sets the wrap parameter specified by mode for the texture coordinates specified by target.

nvmath::Mat44f getMatrix ( void ) const [inline]

Returns the actual texture matrix used to transform the texture during rendering.

Returns:
A 4x4 matrix specifying the actual texture matrix.

const nvmath::Quatf & getOrientation ( void ) const [inline]

Returns the rotational part of the actual texture matrix used to transform the texture during rendering.

Returns:
A quaternion specifying the rotation part of the actual texture matrix.

void setOrientation ( const nvmath::Quatf & orientation ) [inline]

Sets the rotational part of the texture matrix used to transform the texture during rendering.

Parameters:
orientation A quaternion specifying the rotational part of the texture matrix.

const nvmath::Vec3f & getScaling ( void ) const [inline]

Returns the scaling part of the actual texture matrix used to transform the texture during rendering.

Returns:
A 3-component vector specifying the scaling part of the actual texture matrix.

void setScaling ( const nvmath::Vec3f & scale ) [inline]

Sets the scaling part of the texture matrix used to transform the texture during rendering.

Parameters:
scale A 3-component vector specifying the scaling part of the texture matrix.

const nvmath::Vec3f & getTranslation ( void ) const [inline]

Returns the translational part of the actual texture matrix used to transform the texture during rendering.

Returns:
A 3-component vector specifying the translational part of the actual texture matrix.

void setTranslation ( const nvmath::Vec3f & trans ) [inline]

Sets the translational part of the texture matrix used to transform the texture during rendering.

Parameters:
trans A 3-component vector specifying the translational part of the texture matrix.

bool isLoadable ( ) const [inline]

Returns whether the associated texture image could be loaded successfully.

This function is meaningful only if the associated texture image was specified by a texture file, from which to load the image from (see setTextureImageSpec for more information on how to specify a texture image to be associated with a TextureAttributeItem). In the first instance, an associated TextureImage always is supposed to be valid. This status, however, could change if a texture image proves to be not loadable, that is - if loading the image from a file failed for some reason. Note that loading the image, in most cases, is deferred to the first rendering. Hence, calling this function prior to the first rendering, in general is meaningless.

Note:
The function does not reflect whether uploading the associated texture image to the graphics hardware was successful or not!

NVSG_API void setTexGenMode | ( | TexCoordAxis | axis,
 |  | TexGenMode | mode
 | ) |

Sets the texture generation mode for the specified coordinate axis.

If mode indicates TGM_OFF, texture generation for the axis speecified by axis will be disabled.

TexGenMode getTexGenMode ( TexCoordAxis axis ) const [inline]

Returns the texture coordinate generation mode for the specified coordinate axis.

Parameters:
axis specifies the axis to query

NVSG_API void setTexGenLinearPlane | ( | TexCoordAxis | axis,
 |  | TexGenLinearPlane | target,
 |  | const nvmath::Vec4f & | plane
 | ) |

Sets the plane to be used for linear texture generation.

There are distinct planes for each texture coordinate axis. axis indicates the coordinate axis to which the specified plane pertains.

In addition there are two distinct plane targets for which you can specify a plane. If target indicates TGLP_OBJECT, the plane used with texture generation mode TGM_OBJECT_LINEAR will be set, if target indicates TGLP_EYE, the plane used with TGM_EYE_LINEAR will be set. In addition, if target specifies TGLP_OBJECT_AND_EYE, the plane will be used for both mode, TGM_OBJECT_LINEAR and TGM_EYE_LINEAR.

const nvmath::Vec4f & getTexGenLinearPlane | ( | TexCoordAxis | axis,
 |  | TexGenLinearPlane | plane
 | ) | const [inline]

Returns the base plane for linear texture coordinate generation.

Parameters:
axis | specifies the axis to query
target | specifies the plane to query

NVSG_API TextureAttributeItem& operator= ( const TextureAttributeItem & rhs )

Assignement operator.

Performs a deep copy.

size_t getNumberOfOwners ( ) const [inline]

Returns the number of texture attributes that own this item.

const TextureAttribute * getOwner ( size_t index ) const [inline]

Returns the owning texture attribute at the specified zero-based index.

virtual NVSG_API bool isEquivalent | ( | const Object * | p,
 |  | bool | ignoreNames,
 |  | bool | deepCompare
 | ) | const [virtual]

Test for equivalence with an other TextureAttributeItem.

Returns:
true if the TextureAttributeItem p is equivalent to this TextureAttributeItem.
Parameters:
p | TextureAttributeItem to test for equivalence with
ignoreNames | are the names to be ignored?
deepCompare | deep compare?

Reimplemented from Object.

virtual NVSG_API void invalidateIncarnation ( void ) [protected, virtual]

Invalidate the Incarnation.

This function is called from the framework when the Incarnation of this TextureAttributeItem has increased and now is to be marked as invalid. It first increases the Incarnation of all it's owners, then it's own Incarnation is marked as invalid.

Reimplemented from Object.

The documentation for this class was generated from the following file:
  • TextureAttribute.h
Generated on Fri Aug 4 08:38:48 2006 for NVSGSDK by NVIDIA


Member List

TextureAttributeItem Member List

This is the complete list of members for TextureAttributeItem, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone(void) const | TextureAttributeItem | [virtual]
create(void) | TextureAttributeItem | [static]
createFromBase(const Object &rhs) | TextureAttributeItem | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getBorderColor(void) const | TextureAttributeItem | [inline]
getDataID(void) const | TextureAttributeItem | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getEnvColor(void) const | TextureAttributeItem | [inline]
getEnvMode(void) const | TextureAttributeItem | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getMagFilterMode(void) const | TextureAttributeItem | [inline]
getMatrix(void) const | TextureAttributeItem | [inline]
getMinFilterMode(void) const | TextureAttributeItem | [inline]
getName() const | Object |
getNumberOfOwners() const | TextureAttributeItem | [inline]
getObjectCode() const | Object | [inline]
getOrientation(void) const | TextureAttributeItem | [inline]
getOwner(size_t index) const | TextureAttributeItem | [inline]
getScaling(void) const | TextureAttributeItem | [inline]
getTexGenLinearPlane(TexCoordAxis axis, TexGenLinearPlane plane) const | TextureAttributeItem | [inline]
getTexGenMode(TexCoordAxis axis) const | TextureAttributeItem | [inline]
getTextureFileName(std::string &filename) const | TextureAttributeItem | [inline]
getTextureFileName() const | TextureAttributeItem | [inline]
getTextureImage() const | TextureAttributeItem | [inline]
getTranslation(void) const | TextureAttributeItem | [inline]
getWrapMode(TexWrapCoordAxis target) const | TextureAttributeItem | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | TextureAttributeItem | [protected, virtual]
isDataShared(void) const | TextureAttributeItem | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | TextureAttributeItem | [virtual]
isLoadable() const | TextureAttributeItem | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const TextureAttributeItem &rhs) | TextureAttributeItem |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
reloadTextureImage() const | TextureAttributeItem |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setBorderColor(const nvmath::Vec4f &color) | TextureAttributeItem | [inline]
setEnvColor(const nvmath::Vec4f &color) | TextureAttributeItem | [inline]
setEnvMode(TextureEnvMode mode) | TextureAttributeItem | [inline]
setMagFilterMode(TextureMagFilterMode mode) | TextureAttributeItem | [inline]
setMinFilterMode(TextureMinFilterMode mode) | TextureAttributeItem |
setName(const std::string &name) | Object |
setOrientation(const nvmath::Quatf &orientation) | TextureAttributeItem | [inline]
setScaling(const nvmath::Vec3f &scale) | TextureAttributeItem | [inline]
setTexGenLinearPlane(TexCoordAxis axis, TexGenLinearPlane target, const nvmath::Vec4f &plane) | TextureAttributeItem |
setTexGenMode(TexCoordAxis axis, TexGenMode mode) | TextureAttributeItem |
setTextureImageSpec(const std::string &filename, const TextureImage *texImg=NULL) | TextureAttributeItem |
setTranslation(const nvmath::Vec3f &trans) | TextureAttributeItem | [inline]
setWrapMode(TexWrapCoordAxis target, TextureWrapMode mode) | TextureAttributeItem | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
TextureAttributeItem(void) | TextureAttributeItem | [protected]
TextureAttributeItem(const Object &rhs) | TextureAttributeItem | [protected]
TextureAttributeItem(const TextureAttributeItem &rhs) | TextureAttributeItem | [protected]
theAllocator typedef | IAllocator |
validateIncarnation() const | Object | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~TextureAttributeItem() | TextureAttributeItem | [protected, virtual]
Generated on Fri Aug 4 08:38:48 2006 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 Fri Aug 4 08:38:47 2006 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, 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 Fri Aug 4 08:38:47 2006 for NVSGSDK by NVIDIA


TextureImage Class Reference

A texture image abstraction class. More...

#include <TextureImage.h>

Inheritance diagram for TextureImage:

[legend]
Collaboration diagram for TextureImage:

[legend]
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_NUM_FORMATS
}
Enumeration type to describe a pixel data format. More...

enum PixelDataType {
IMG_UNKNOWN_TYPE = -1, IMG_BYTE = 0, IMG_UNSIGNED_BYTE, IMG_SHORT,
IMG_UNSIGNED_SHORT, IMG_INT, IMG_UNSIGNED_INT, IMG_FLOAT,
IMG_HALF, IMG_NUM_TYPES
}
Enumeration type to describe the data type of pixel data. More...

enum {
F_PRESERVE_IMAGE_DATA_AFTER_UPLOAD = BIT0, F_IMAGE_STREAM = BIT2, 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
}
Available creation flags. More...

Public Member Functions

NVSG_API const TextureImage * | clone () const
Instantiates a copy of this texture image.

NVSG_API size_t | createImage (unsigned int width, unsigned int height, unsigned int depth, unsigned int bpp, PixelFormat format, PixelDataType type, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >())
Creates an image.

NVSG_API void | releaseImages ()
Releases all contained image data.

NVSG_API void | incrementMipmapUseCount ()
Increments (increases by one) the mipmap use count.

NVSG_API void | decrementMipmapUseCount ()
Decrements (decreases by one) the mipmap use count.

NVSG_API size_t | getMipmapUseCount () const
Returns the actual mipmap use count.

NVSG_API bool | createMipmaps ()
Creates all mipmap levels for all included images.

NVSG_API size_t | getNumberOfImages () const
Returns number of containing images (e.g. 6 for cubemaps).

NVSG_API size_t | getNumberOfMipmaps (size_t image=0) const
Returns the number of mipmap levels available for the specified image.

NVSG_API PixelFormat | getFormat (size_t image=0, size_t mipmap=0) const
Returns the PixelFormat of the specified mipmap level for a given image.

NVSG_API PixelDataType | getType (size_t image=0, size_t mipmap=0) const
Returns the PixelDataType of the specified image.

NVSG_API unsigned int | getWidth (size_t image=0, size_t mipmap=0) const
Returns the width in pixels of the specified mipmap.

NVSG_API unsigned int | getHeight (size_t image=0, size_t mipmap=0) const
Returns the height in pixels of the specified mipmap.

NVSG_API unsigned int | getDepth (size_t image=0, size_t mipmap=0) const
Returns the depth in pixels of the specified mipmap.

NVSG_API unsigned int | getBytesPerPixel (size_t image=0, size_t mipmap=0) const
Returns the number of bytes per pixel of the specified mipmap.

NVSG_API unsigned int | getBytesPerScanLine (size_t image=0, size_t mipmap=0) const
Returns the number of bytes per scan line of the specified mipmap.

NVSG_API unsigned int | getBytesPerImage (size_t image=0, size_t mipmap=0) const
Returns the number of bytes per image slice of the specified mipmap.

NVSG_API const void * | getPixels (size_t image=0, size_t mipmap=0) const
Returns a pointer to the raw pixel data of the specified mipmap.

NVSG_API unsigned int | getUnpackAlignment () const
Returns the alignment for the start of each pixel row in memory.

NVSG_API bool | scale (size_t image, unsigned int width, unsigned int Height=1, unsigned int depth=1)
Scales the specified image.

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 | 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 | 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.

TextureImage & | operator= (const TextureImage &rhs)
Assigns new contents to a TextureImage object.

NVSG_API void | mirrorX (size_t image)
Mirror the image over the x-axis.

NVSG_API void | mirrorY (size_t image)
Mirror the image over the y-axis.

Static Public Member Functions

NVSG_API const TextureImage * | create (unsigned int flags=0)
Instantiates an empty TextureImage object.

NVSG_API const TextureImage * | createFromFile (const std::string &filename, unsigned int flags=0)
Instantiates a TextureImage object filled with image data loaded from a file.

Protected Member Functions

TextureImage (unsigned int flags)
Explicit creation allowed only via create.

TextureImage (const TextureImage &)
Copying allowed only via clone.

Detailed Description

A texture image abstraction class.

Member Enumeration Documentation

enum PixelFormat

Enumeration type to describe a pixel data format.

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

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_FLOAT | single-precision floating point (32-bit)
IMG_HALF | half-precision floating point (16-bit)

anonymous enum

Available creation flags.

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_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

Constructor & Destructor Documentation

TextureImage ( unsigned int flags ) [explicit, protected]

Explicit creation allowed only via create.

TextureImage ( const TextureImage & ) [protected]

Copying allowed only via clone.

Member Function Documentation

NVSG_API const TextureImage* create ( unsigned int flags = 0 ) [static]

Instantiates an empty TextureImage object.

The returned TextureImage object does not contain any image data after creation. Use createImage to create image data for this object.

Note, that you first need to write-lock the TextureImage object to access its non-const interface. For this you must call beginEdit on the pointer to the const TextureImage object. beginEdit write-locks the object and returns a pointer to the non-const object, which can be used to access the non-const interface of TextureImage. After completing all desired edit operations, you must in turn call endEdit on the pointer to the non-const TextureImage object to unlock the TextureImage object again. Note, that you must not use the pointer to the non-const object after unlocking the object this way!

Client code may provide optional creation flags:

Specify 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.

Specifying F_IMAGE_STREAM forces all subsequent created images to be treated as stream images. In this case only the dimensions and formats specified through createImage will be stored but no pixel data will be copied to the internal structures.

Parameters:
flags Optional creation flags

NVSG_API const TextureImage* createFromFile | ( | const std::string & | filename,
 |  | unsigned int | flags = 0
 | ) | [static]

Instantiates a TextureImage object filled with image data loaded from a file.

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 const TextureImage* clone ( ) const

Instantiates a copy of this texture image.

Returns:
A pointer to the clone.

NVSG_API size_t createImage | ( | unsigned int | width,
 |  | unsigned int | height,
 |  | unsigned int | depth,
 |  | unsigned int | bpp,
 |  | PixelFormat | format,
 |  | 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 behaviour.

The behaviour 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.
Parameters:
width | width in pixels
height | height in pixels
depth | depth in pixels
bpp | bytes per pixel
format | format of image data
type | type of image data
pixels | raw pixel data
mipmaps | !< additional mipmap levels (optional)

NVSG_API void releaseImages ( )

Releases all contained image data.

The function frees all contained image data including all mipmap levels that might have been created before.

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

size_t 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 ( )

Creates all mipmap levels for all included images.

The function explicitly creates all mipmap levels for all images included. Previously created levels will be released.

The function expects all including images to be of power-of-two dimensions. Client code needs to check this and probably perform some scaling before calling this function. Calling the function for non power-of-two images results in undefined behavior!

Returns:
true if all levels have been created successfully, false otherwise.

size_t getNumberOfImages ( ) const [inline]

Returns number of containing images (e.g. 6 for cubemaps).

Returns:
The number of images contained.

size_t getNumberOfMipmaps ( size_t image = 0 ) const [inline]

Returns the number of mipmap levels available for the specified image.

Passing an invalid image index results in undefined behavior! A valid image index ranges from 0 to getNumberOfImages()-1.

Returns:
The number of mipmap levels available for the image specified by image.
Parameters:
image Zero-based image index.

TextureImage::PixelFormat getFormat | ( | size_t | image = 0,
 |  | size_t | 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.

TextureImage::PixelDataType getType | ( | size_t | image = 0,
 |  | size_t | 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 | ( | size_t | image = 0,
 |  | size_t | mipmap = 0
 | ) | const [inline]

Returns the width in pixels of the specified mipmap.

The function returns the width in pixels 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 width in pixels of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

unsigned int getHeight | ( | size_t | image = 0,
 |  | size_t | mipmap = 0
 | ) | const [inline]

Returns the height in pixels of the specified mipmap.

The function returns the height in pixels 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 height in pixels of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

unsigned int getDepth | ( | size_t | image = 0,
 |  | size_t | mipmap = 0
 | ) | const [inline]

Returns the depth in pixels of the specified mipmap.

The function returns the depth in pixels 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 depth in pixels of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

unsigned int getBytesPerPixel | ( | size_t | image = 0,
 |  | size_t | 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 | ( | size_t | image = 0,
 |  | size_t | mipmap = 0
 | ) | const [inline]

Returns the number of bytes per scan line of the specified mipmap.

The function returns the number of bytes per scan line 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 scan line of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

unsigned int getBytesPerImage | ( | size_t | image = 0,
 |  | size_t | mipmap = 0
 | ) | const [inline]

Returns the number of bytes per image slice of the specified mipmap.

The function returns the number of bytes per image slice 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 image slice of the specified mipmap.
Parameters:
image | Zero-based image index.
mipmap | Zero-based mipmap level.

const void * getPixels | ( | size_t | image = 0,
 |  | size_t | 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.

unsigned int getUnpackAlignment ( ) const [inline]

Returns the alignment for the start of each pixel row in memory.

NVSG_API bool scale | ( | size_t | image,
 |  | unsigned int | width,
 |  | unsigned int | Height = 1,
 |  | unsigned int | depth = 1
 | ) |

Scales the specified image.

The function scales the image specified by image according to the input dimensions passed. Currently the function does a nearest filter scaling only. This is subject to change, though.

Passing an invalid image index results in undefined behavior! A valid image index ranges from 0 to getNumberOfImages()-1.

Returns:
true if scaling was successful, false otherwise.
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.

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 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.

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.

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 ( size_t 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 ( size_t 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 Fri Aug 4 08:38:51 2006 for NVSGSDK by NVIDIA


Member List

TextureImage Member List

This is the complete list of members for TextureImage, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clone() const | TextureImage |
convert2DToCubeMap() | TextureImage |
create(unsigned int flags=0) | TextureImage | [static]
createFromFile(const std::string &filename, unsigned int flags=0) | TextureImage | [static]
createImage(unsigned int width, unsigned int height, unsigned int depth, unsigned int bpp, PixelFormat format, PixelDataType type, const void *pixels, const std::vector< const void * > &mipmaps=std::vector< const void * >()) | TextureImage |
createMipmaps() | TextureImage |
decrementMipmapUseCount() | TextureImage |
demandUpload() | TextureImage | [inline]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
F_IMAGE_STREAM 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 |
finishUpload() | TextureImage |
getBytesPerImage(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getBytesPerPixel(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getBytesPerScanLine(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getCreationFlags() const | TextureImage | [inline]
getDepth(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFormat(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getHeight(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getMipmapUseCount() const | TextureImage | [inline]
getNumberOfImages() const | TextureImage | [inline]
getNumberOfMipmaps(size_t image=0) const | TextureImage | [inline]
getPixels(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getType(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
getUnpackAlignment() const | TextureImage | [inline]
getWidth(size_t image=0, size_t mipmap=0) const | TextureImage | [inline]
IAllocator() | IAllocator | [inline]
IMG_BGR enum value | TextureImage |
IMG_BGRA enum value | TextureImage |
IMG_BYTE enum value | TextureImage |
IMG_COLOR_INDEX enum value | TextureImage |
IMG_FLOAT enum value | TextureImage |
IMG_HALF enum value | TextureImage |
IMG_INT enum value | TextureImage |
IMG_LUMINANCE enum value | TextureImage |
IMG_LUMINANCE_ALPHA enum value | TextureImage |
IMG_NUM_FORMATS enum value (defined in TextureImage) | TextureImage |
IMG_NUM_TYPES enum value (defined in TextureImage) | TextureImage |
IMG_RGB enum value | TextureImage |
IMG_RGBA enum value | TextureImage |
IMG_SHORT enum value | TextureImage |
IMG_UNKNOWN_FORMAT enum value | TextureImage |
IMG_UNKNOWN_TYPE enum value | TextureImage |
IMG_UNSIGNED_BYTE enum value | TextureImage |
IMG_UNSIGNED_INT enum value | TextureImage |
IMG_UNSIGNED_SHORT enum value | TextureImage |
incrementMipmapUseCount() | TextureImage |
is1D() const | TextureImage | [inline]
is2D() const | TextureImage | [inline]
is3D() const | TextureImage | [inline]
isCubeMap() const | TextureImage | [inline]
isFloatingPoint() const | TextureImage |
isImageStream() const | TextureImage | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isUploadDemanded() const | TextureImage | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
markUnshareable() | RCObject | [inline]
mirrorX(size_t image) | TextureImage |
mirrorY(size_t image) | TextureImage |
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const TextureImage &rhs) | TextureImage |
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PixelDataType enum name | TextureImage |
PixelFormat enum name | TextureImage |
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
releaseImages() | TextureImage |
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
scale(size_t image, unsigned int width, unsigned int Height=1, unsigned int depth=1) | TextureImage |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
TextureImage(unsigned int flags) | TextureImage | [explicit, protected]
TextureImage(const TextureImage &) | TextureImage | [protected]
theAllocator typedef | IAllocator |
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~TextureImage() (defined in TextureImage) | TextureImage | [protected, virtual]
Generated on Fri Aug 4 08:38:51 2006 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

virtual NVSG_API const TextureImage * | load (const std::string &filename)=0
Pure virtual interface function to load a Texture.

Protected Member Functions

virtual NVSG_API | ~TextureLoader ()
Protected virtual destructor.

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

virtual NVSG_API const TextureImage* load ( const std::string & filename ) [pure virtual]

Pure virtual interface function to load a Texture.

Loads a texture file given by filename. The PlugIn must return the image 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.

Returns:
A pointer to the loaded Texture if successful, a null pointer otherwise.
Parameters:
filename texture file to load

Implemented in ILTexLoader.

The documentation for this class was generated from the following file:
  • PlugInterface.h
Generated on Fri Aug 4 08:38:23 2006 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]
deleteThis(void)=0 | PlugIn | [protected, pure virtual]
load(const std::string &filename)=0 | TextureLoader | [pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [inline]
~PlugIn() (defined in PlugIn) | PlugIn | [inline, protected, virtual]
~TextureLoader() | TextureLoader | [protected, virtual]
Generated on Fri Aug 4 08:38:23 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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 Fri Aug 4 08:40:20 2006 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
}
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.

Protected Attributes

nvui::MouseInput m_mouseInput
MouseInput object for tracking mouse events.

nvui::KeyInput m_keyInput
KeyInput object for tracking keyboard events.

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 | ORBIT
Button configuration for orbit (_LEFT_MOUSE_BTN).

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

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

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 ORBIT [static, protected]

Button configuration for orbit (_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.

The documentation for this class was generated from the following file:
  • TrackballCameraManipulator.h
Generated on Fri Aug 4 08:40:02 2006 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 |
DOLLY1 | TrackballCameraManipulator | [protected, static]
DOLLY2 | TrackballCameraManipulator | [protected, static]
isActive() | TrackballCameraManipulator | [virtual]
isDolly() | TrackballCameraManipulator |
isOrbit() | TrackballCameraManipulator |
isPan() | TrackballCameraManipulator |
keyDown(UINT key) | TrackballCameraManipulator |
keyUp(UINT key) | TrackballCameraManipulator |
m_keyInput | TrackballCameraManipulator | [protected]
m_mouseInput | TrackballCameraManipulator | [protected]
m_renderArea | Manipulator | [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]
PAN1 | TrackballCameraManipulator | [protected, static]
PAN2 | TrackballCameraManipulator | [protected, static]
reset() | TrackballCameraManipulator |
setRenderArea(nvui::RenderArea *renderArea) | Manipulator | [inline]
TrackballCameraManipulator() | TrackballCameraManipulator |
updateFrame() | TrackballCameraManipulator | [virtual]
~Manipulator() | Manipulator | [virtual]
~TrackballCameraManipulator() | TrackballCameraManipulator | [virtual]
Generated on Fri Aug 4 08:40:02 2006 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 Attributes

nvui::MouseInput m_mouseInput
MouseInput object for tracking mouse events.

nvui::KeyInput m_keyInput
KeyInput object for tracking keyboard events.

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

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.

The documentation for this class was generated from the following file:
  • TrackballTransformManipulator.h
Generated on Fri Aug 4 08:40:03 2006 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 |
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_transformPath | TransformManipulator | [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 |
PAN1 | TrackballTransformManipulator | [protected, static]
PAN2 | TrackballTransformManipulator | [protected, static]
reset() | TrackballTransformManipulator |
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 Fri Aug 4 08:40:03 2006 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 inverse of the current 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.

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:
Mat44f that describes the transformation

NVSG_API Mat44f getInverse ( void ) const

Get the inverse of the current transformation.

Returns:
Mat44f that describes the inverse transformation

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 Fri Aug 4 08:37:23 2006 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 &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 Fri Aug 4 08:37:23 2006 for NVSGSDK by NVIDIA


trafo_t Struct Reference

The trafo_t structure specifies how a transfrmation 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 transfrmation 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 Fri Aug 4 08:37:07 2006 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 Fri Aug 4 08:37:07 2006 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

virtual NVSG_API const Transform * | clone (void) const
Create a new Transform by copying from this.

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 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.

Static Public Member Functions

NVSG_API const Transform * | create (void)
Create a Transform.

NVSG_API const Transform * | createFromBase (const Group &rhs)
Create a Transform by copying from a Group.

Protected Member Functions

NVSG_API | Transform (void)
Protected default constructor to prevent explicit creation.

NVSG_API | Transform (const Group &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Transform (const Transform &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Transform (void)
Protected destructor to prevent explicit creation.

virtual NVSG_API nvmath::Sphere3f | calculateBoundingSphere (void) const
Calculate the bounding sphere of this Transform.

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 ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Transform::create.

NVSG_API Transform ( const Group & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Group to use as a base of the new Transform.
Remarks:
This constructor is never used explicitly, but only inside Transform::createFromBase.
See also:
Group

NVSG_API Transform ( const Transform & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Transform to copy from
Remarks:
This constructor is never used explicitly, but only inside Transform::create.

virtual NVSG_API ~Transform ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Transform is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Transform* create ( void ) [static]

Create a Transform.

Returns:
A pointer to a constant Transform.
Remarks:
Per default a Transform is empty and the transformation is the identity.

Reimplemented from Group.

NVSG_API const Transform* createFromBase ( const Group & rhs ) [static]

Create a Transform by copying from a Group.

Parameters:
rhs A reference to the constant Group to copy from.
Returns:
A pointer to a constant Transform.
Remarks:
All the data from the Group rhs is used as the base information for the newly created Transform. Transform specific data is initialized as if Transform::create would have been called.
See also:
Group

virtual NVSG_API const Transform* clone ( void ) const [virtual]

Create a new Transform by copying from this.

Returns:
A pointer to a constant Transform.
Remarks:
The newly created Transform is an exact copy of this.

Reimplemented from Group.

Reimplemented in AnimatedTransform.

const nvmath::Trafo & getTrafo ( void ) const [inline]

Get the transformation represented by this Transform.

Returns:
A reference to the constant nvmath::Trafo, representing the transformation.
See also:
nvmath::Trafo, setTrafo

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.

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::Sphere3f calculateBoundingSphere ( void ) 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.

The documentation for this class was generated from the following file:
  • Transform.h
Generated on Fri Aug 4 08:38:55 2006 for NVSGSDK by NVIDIA


Member List

Transform Member List

This is the complete list of members for Transform, including all inherited members.
activateClipPlane(size_t index) | Group | [inline]
addChild(const Node *child, size_t position=0xFFFFFFFF) | Group |
addClipPlane(const nvmath::Plane3f &plane, bool active=true) | Group | [inline]
addHints(unsigned short hints) | Node | [inline]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
assertInvalidBoundingSphere() const | Node |
calculateBoundingSphere(void) const | Transform | [protected, virtual]
clone(void) const | Transform | [virtual]
containsCgFx() const | Group | [virtual]
containsHints(unsigned short hints) const | Node |
containsLight() const | Group | [virtual]
containsTransparentGeometry() const | Node |
create(void) | Transform | [static]
createFromBase(const Group &rhs) | Transform | [static]
nvsg::Group::createFromBase(const Node &rhs) | Group | [static]
deactivateClipPlane(size_t index) | Group | [inline]
determineHintsContainment(unsigned short hints) const | Group | [protected, virtual]
determineTransparencyContainment() const | Group | [protected, virtual]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnnotation() const | Node |
getBoundingSphere() const | Node |
getChild(size_t position) const | Group | [inline]
getChildPositions(const Node *node, std::vector< size_t > &positions) const | Group |
getClipPlane(size_t index) const | Group | [inline]
getDataID() const | Object | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHints(unsigned short mask=0xFFFF) const | Node | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfActiveClipPlanes() const | Group |
getNumberOfChildren() const | Group | [inline]
getNumberOfClipPlanes() const | Group | [inline]
getNumberOfFrames() const | Group | [virtual]
getNumberOfParents() const | Node | [inline]
getObjectCode() const | Object | [inline]
getParent(size_t index) const | Node | [inline]
getTrafo(void) const | Transform | [inline]
Group() | Group | [protected]
Group(const Node &rhs) | Group | [explicit, protected]
Group(const Group &rhs) | Group | [protected]
hasChild(const Node *node) const | Group |
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere() | Node |
invalidateCaches(const Node *child, bool insert) | Group | [protected]
invalidateCgFxContainment() | Group | [virtual]
invalidateHintsContainment(unsigned short hints) | Node |
invalidateIncarnation() | Node | [protected, virtual]
invalidateLightContainment() | Group | [virtual]
invalidateNumberOfFrames() const | Group | [virtual]
invalidateTransparencyContainment() | Node |
isClipPlaneActive(size_t index) const | Group | [inline]
isDataShared() const | Object | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | Transform | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
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(void) | Node | [protected]
Node(const Node &rhs) | Node | [protected]
NodeHints enum name | Node |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
postAddChild(size_t position) | Group | [protected, virtual]
postRemoveChild(size_t position) | Group | [protected, virtual]
preAddChild(size_t position) | Group | [protected, virtual]
preRemoveChild(size_t position) | Group | [protected, virtual]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeChild(const Node *child) | Group |
removeChild(size_t position) | Group |
removeHints(unsigned short hints) | Node | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
replaceChild(const Node *newChild, const Node *oldChild) | Group |
replaceChild(const Node *newChild, size_t position) | Group |
setAnnotation(const std::string &anno) | Node |
setClipPlane(size_t 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]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
Transform(void) | Transform | [protected]
Transform(const Group &rhs) | Transform | [protected]
Transform(const Transform &rhs) | Transform | [protected]
validateIncarnation() const | Group | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Group() | Group | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Node(void) | Node | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Transform(void) | Transform | [protected, virtual]
Generated on Fri Aug 4 08:38:55 2006 for NVSGSDK by NVIDIA


TransformCombineTraverser Class Reference

Traverser that combines identical Transforms. More...

#include <TransformCombineTraverser.h>

Inheritance diagram for TransformCombineTraverser:

[legend]
Collaboration diagram for TransformCombineTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | TransformCombineTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~TransformCombineTraverser (void)
Protected destructor to prevent instantiation of a StateSetUnifyTraverser on stack.

virtual NVSG_API void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Combine compatible Transform objects directly underneath this AnimatedTransform.

virtual NVSG_API void | handleBillboard (const nvsg::Billboard *p)
Combine compatible Transform objects directly underneath this Billboard.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Combine compatible Transform objects directly underneath this Group.

virtual NVSG_API void | handleTransform (const nvsg::Transform *p)
Combine compatible Transform objects directly underneath this Transform.

Detailed Description

Traverser that combines identical Transforms.

Identical Transforms beneath a Group or an other Transform are recognized and their children are combined to a single Transform. This way, redundant objects are removed, thereby reducing storage space as well as run time.

Note:
When there is a LightSource inbetween of some Transform nodes, unifying is not allowed (and therefore not performed) across this LightSource.

Constructor & Destructor Documentation

NVSG_API TransformCombineTraverser ( void )

Constructor.

virtual NVSG_API ~TransformCombineTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a StateSetUnifyTraverser on stack.

Member Function Documentation

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Combine compatible Transform objects directly underneath this AnimatedTransform.

An AnimatedTransform is handled as a Transform.

Parameters:
p currently visited AnimatedTransform

Reimplemented from Traverser.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Combine compatible Transform objects directly underneath this Billboard.

A Billboard is handled as a Group.

Parameters:
p Points to the currently visited Billboard object.

Reimplemented from Traverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Combine compatible Transform objects directly underneath this Group.

Parameters:
p Points to the currently visited Group object.

Reimplemented from Traverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Combine compatible Transform objects directly underneath this Transform.

A Transform is handled as a Group.

Parameters:
p Points to the currently visited Transform object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • TransformCombineTraverser.h
Generated on Fri Aug 4 08:39:46 2006 for NVSGSDK by NVIDIA


Member List

TransformCombineTraverser Member List

This is the complete list of members for TransformCombineTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | OptimizeTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | TransformCombineTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | TransformCombineTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | TransformCombineTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | TransformCombineTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
TransformCombineTraverser(void) | TransformCombineTraverser |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~TransformCombineTraverser(void) | TransformCombineTraverser | [protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:46 2006 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 Fri Aug 4 08:40:04 2006 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 Fri Aug 4 08:40:04 2006 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 transformtion from clip space to view space.

NVSG_API const nvmath::Mat44f | getModelToClip (void) const
Get the transformtion from model space to clip space.

NVSG_API const nvmath::Mat44f | getModelToView (void) const
Get the transformtion from model space to view space.

NVSG_API const nvmath::Mat44f & | getModelToWorld (void) const
Get the transformtion from model space to world space.

NVSG_API const nvmath::Mat44f & | getViewToClip (void) const
Get the transformtion from view space to clip space.

NVSG_API const nvmath::Mat44f | getViewToModel (void) const
Get the transformtion from view space to model space.

NVSG_API const nvmath::Mat44f & | getViewToWorld (void) const
Get the transformtion from view space to world space.

NVSG_API const nvmath::Mat44f & | getWorldToModel (void) const
Get the transformtion from world space to model space.

NVSG_API const nvmath::Mat44f & | getWorldToView (void) const
Get the transformtion from world space to view space.

NVSG_API size_t | 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 transformtion from clip space to view space.

const nvmath::Mat44f getModelToClip ( void ) const [inline]

Get the transformtion from model space to clip space.

const nvmath::Mat44f getModelToView ( void ) const [inline]

Get the transformtion from model space to view space.

const nvmath::Mat44f & getModelToWorld ( void ) const [inline]

Get the transformtion from model space to world space.

const nvmath::Mat44f & getViewToClip ( void ) const [inline]

Get the transformtion from view space to clip space.

const nvmath::Mat44f getViewToModel ( void ) const [inline]

Get the transformtion from view space to model space.

const nvmath::Mat44f & getViewToWorld ( void ) const [inline]

Get the transformtion from view space to world space.

const nvmath::Mat44f & getWorldToModel ( void ) const [inline]

Get the transformtion from world space to model space.

const nvmath::Mat44f & getWorldToView ( void ) const [inline]

Get the transformtion from world space to view space.

size_t 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 Fri Aug 4 08:40:21 2006 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 Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


Traverser Class Reference

Base class providing an interface for read-write traversing of a given scene graph. More...

#include <Traverser.h>

Inheritance diagram for Traverser:

[legend]
Collaboration diagram for Traverser:

[legend]
List of all members.

Public Member Functions

NVSG_API void | apply (const nvsg::Scene *scene)
Start traversing a scene graph.

NVSG_API void | interruptTraversal ()
Immediately interrupts traversal.

NVSG_API bool | wasTraversalInterrupted ()
Check for traversal interruption.

NVSG_API const nvutil::ProblemLogList & | getProblems ()
Get the problem log.

Protected Member Functions

NVSG_API | Traverser (bool readOnly=true)
Default construction on instantiation.

virtual NVSG_API | ~Traverser (void)
Protected destructor to prevent instantiation of a Traverser.

virtual NVSG_API void | doApply (const nvsg::Scene *scene)
Initiate traversing a given scene graph.

virtual NVSG_API bool | preApply (const nvsg::Node *root)
Notifier called from the framework immediately before traversal starts.

virtual NVSG_API void | postApply (const nvsg::Node *root)
Notifier called from the framework immediately after traversal.

template<typename HandlerType> void | addObjectHandler (unsigned int objectCode, HandlerType handler)
Add a handler routine for a concrete Object derived object.

void | traverseObject (const nvsg::Object *object)
Start traversing a general object.

template<typename T> void | traverseObject (const nvsg::Object *object, T arg)
Start traversing a general object.

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.

virtual NVSG_API void | handleGroup (const nvsg::Group *p)
Routine to handle a Group 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 | 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 | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Routine to handle a AnimatedQuads 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 | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Routine to handle a AnimatedTriangles 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 | 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 | handleShape (const nvsg::Shape *p)
Routine to handle a Shape object while traversing the scene graph.

virtual NVSG_API void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
Routine to handle a VertexAttributeSet 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 | handleBitmap (const nvsg::Bitmap *p)
Routine to handle a Bitmap.

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 | handleMapArray (const nvsg::MapArray *p)
Routine to handle a MapArray.

virtual NVSG_API void | handleMapElement (const nvsg::MapElement *p)
Routine to handle a MapElement.

virtual NVSG_API void | handleMapList (const nvsg::MapList *p)
Routine to handle a MapList.

virtual NVSG_API void | handleMapMatrix (const nvsg::MapMatrix *p)
Routine to handle a MapMatrix.

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 | handleTextureAttributeItem (const nvsg::TextureAttributeItem *p, size_t tu)
Routine to handle a TextureAttributeItem object while traversing the scene graph.

virtual NVSG_API void | handleParallelCamera (const nvsg::ParallelCamera *p, const nvsg::Node *root)
Routine to handle a ParallelCamera object while traversing the scene graph.

virtual NVSG_API void | handlePerspectiveCamera (const nvsg::PerspectiveCamera *p, const nvsg::Node *root)
Routine to handle a PerspectiveCamera 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 | handleFramedVNVectorAnimation (const nvsg::FramedAnimation< nvsg::VNVector > *p)
Routine to handle a FramedAnimation<VNVector> 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 | handleLinearInterpolatedVNVectorAnimation (const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p)
Routine to handle a LinearInterpolatedAnimation<VNVector> object while traversing the scene graph.

virtual NVSG_API void | handleHighlightBox (const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive)
Routine to handle a HighlightBox object while traversing the scene graph.

virtual NVSG_API void | handleHighlightEdges (const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive)
Routine to handle a HighlightEdges object while traversing the scene graph.

virtual NVSG_API bool | preTraverseRoot (const nvsg::Camera *p, const nvsg::Node *root)
This function will be called from the framework immediately before the scene graph is traversed.

virtual NVSG_API void | postTraverseRoot (const nvsg::Camera *p, const nvsg::Node *root)
This function will be called from the framework immediately after the scene graph has been traversed.

virtual NVSG_API bool | preTraverseGroup (const nvsg::Group *p)
This function will be called from the framework immediately before a Group is traversed.

virtual NVSG_API void | postTraverseGroup (const nvsg::Group *p)
This function will be called from the framework immediately after a Group has been traversed.

virtual NVSG_API bool | preTraverseDrawables (const nvsg::GeoNode *p, size_t i)
This function will be called from the framework immediately before coherent Drawables will be traversed.

virtual NVSG_API void | postTraverseDrawables (const nvsg::GeoNode *p, size_t i)
This function will be called from the framework immediately after coherent Drawables have been traversed.

virtual NVSG_API bool | preTraverseDrawable (const nvsg::Drawable *p)
This function will be called from the framework immediately before a single Drawable is traversed.

virtual NVSG_API void | postTraverseDrawable (const nvsg::Drawable *p)
This function will be called from the framework immediately after a Drawable has been traversed.

virtual NVSG_API void | traverseHighlightObject (const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive)
This function will be called from the framework when a HighlightObject is visited.

virtual NVSG_API void | traverseLight (const nvsg::LightSource *p)
This function will be called from the framework when a LightSource node is visited.

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *p)
This function will be called from the framework when a PrimitiveSet is visited.

virtual NVSG_API void | preTraverseMap (const nvsg::MapArray *p, size_t index)
This function will be called from the framework before a Map as part of a MapArray is traversed.

virtual NVSG_API void | postTraverseMap (const nvsg::MapArray *p, size_t index)
This function will be called from the framework after a Map as part of a MapArray has been traversed.

virtual NVSG_API void | preTraverseMap (const nvsg::MapMatrix *p, size_t col, size_t row)
This function will be called from the framework before a Map as part of a MapMatrix is traversed.

virtual NVSG_API void | postTraverseMap (const nvsg::MapMatrix *p, size_t col, size_t row)
This function will be called from the framework after a Map as part of a MapMatrix is traversed.

virtual NVSG_API void | preTraverseMapColumn (const nvsg::MapMatrix *p, size_t col)
This function will be called from the framework before a column of Maps of a MapMatrix is traversed.

virtual NVSG_API void | postTraverseMapColumn (const nvsg::MapMatrix *p, size_t col)
This function will be called from the framework after a column of Maps of a MapMatrix is traversed.

template<typename T> T * | beginEdit (const T *obj) const
Get a writable pointer to a constant object.

template<typename T> const T * | endEdit (const T *obj) const
End the editing operation on a constant object.

Protected Attributes

std::stack< size_t > | m_lodStack
Holds the index of the current LOD level.

std::stack< const nvsg::CullData * > | m_cullStack
Holds the cull data corresponding to the traversed tree.

const nvsg::ViewState * | m_viewState
Always NULL in the base class. Derived classes can set it.

nvutil::ProblemLog | m_problemLog
const nvsg::StateSet * | m_nullStateSet
Serves default state handling.

bool volatile | m_interrupt
Flag to assign an interrupt request.

bool | m_interrupted
Flag to assign whether the current traversal has been interrupted.

Detailed Description

Base class providing an interface for read-write traversing of a given scene graph.

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 performes a defined operation for each by means of an overloadable handler routine.

The Traverser 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 base 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 Traverser or one of its derived traversers, and overload the corresponding handler routines as needed.

Constructor & Destructor Documentation

NVSG_API Traverser ( bool readOnly = true ) [protected]

Default construction on instantiation.

The constructor is protected, and hence, a Traverser object cannot be instantiated directly but only by deriving from Traverser.

virtual NVSG_API ~Traverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a Traverser.

Member Function Documentation

NVSG_API void apply ( const nvsg::Scene * scene )

Start traversing a scene graph.

This serves as the main entry point for clients to traverse a certain scene graph. The function waits to gain read access to the Scene object pointed to by scene.

Note:
Some traverser need a valid ViewState object which have to set via the setViewState() function. If an ViewState object is provided, the function also waits to gain read access to the ViewState object. After the function gains read access to the Scene object (and the ViewState object), it calls the protected and overloadable doApply member function to start traversing the corresponding scene graph. After traversing is completed, the function releases the read access to the Scene object and the ViewState object.

The behavior is undefined if scene points to an invalid location.

Parameters:
scene Abstracts the scene graph to be traversed.

void interruptTraversal ( ) [inline]

Immediately interrupts traversal.

This function can be used to immediately interrupt the traversal from another thread.

bool wasTraversalInterrupted ( ) [inline]

Check for traversal interruption.

Returns:
This function returns true if the traversal was interrupted, it returns false if there was no interruption and the tree was completely traversed.
See also:
interruptTraversal

NVSG_API const nvutil::ProblemLogList& getProblems ( )

Get the problem log.

Get a list of all the problems that popped up during construction of the Traverser. Check this list after construction to get an overview of features that the Traverser could not provide.

Returns:
Current list of problems.

virtual NVSG_API void doApply ( const nvsg::Scene * scene ) [protected, virtual]

Initiate traversing a given scene graph.

This overloadable function is called from the traverser's entry point apply . The base implementation first initiates the traversing of the scene's global states, if available. After that the scene itself is traversed.

Custom traversers may override this function in order to implement initial work to be done before traversing the scene. For derived classes to ensure proper traversing of the scene, it is recommended to always call the base implementation after the initial work has been done.

Parameters:
scene Points to the scene to be traversed.

Reimplemented in WRLLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, CullTraverser, DestrippingTraverser, GeoNodeUnifyTraverser, GLTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODEliminateTraverser, NormalizeTraverser, OptimizeTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, RenderTraverser, SearchTraverser, SmoothTraverser, StateSetUnifyTraverser, SwitchToGroupTraverser, VertexAttributeSetUnifyTraverser, and VertexUnifyTraverser.

virtual NVSG_API bool preApply ( const nvsg::Node * root ) [protected, virtual]

Notifier called from the framework immediately before traversal starts.

Parameters:
root Root node that will be traversed immediately after this call.
Returns:
The default implementation always return true, forcing the traversal of the specified root node 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. It is strongly recommended for custom overrides to call the base implementation, in particular in cases traversal should be proceeded.

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.
See also:
postApply

virtual NVSG_API void postApply ( const nvsg::Node * root ) [protected, virtual]

Notifier called from the framework immediately after traversal.

Parameters:
root Root node that was traversed immediately before this call.
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. Not calling the base implementation might result in undefined runtime behavior.

At the time of call, a custom override can rely on the optional Scene and the optional ViewState both no longer being locked for read or write access by the calling thread.
See also:
preApply

void addObjectHandler | ( | unsigned int | objectCode,
 |  | HandlerType | handler
 | ) | [inline, protected]

Add a handler routine for a concrete Object derived object.

The function registers the handler routine specified by handler to handle a concrete 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.

Note:
A possibly pre-registered handler routine for the specified object will be overridden by the new handler.
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 handler routines for a certain known objects but to overload the corresponding handler routines. 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 indispensible if newly invented objects, and hence, objects that are unknown by the Traverser base class, need to be considered for traversing.
Parameters:
objectCode | Object code to identify an object type at run-time.
handler | Specifies the address of the handler routine.

void traverseObject ( const nvsg::Object * object ) [inline, protected]

Start traversing 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 handler routine. After the handler routine returns, the function releases the read access to the object.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
object Points to the object to be traversed.

void traverseObject | ( | const nvsg::Object * | object,
 |  | T | arg
 | ) | [inline, protected]

Start traversing 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 handler routine with the additional argument arg. After the handler 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 handler routine.
Parameters:
object | Points to the object to be traversed.
arg | Specifies an additional argument that will be passed to the handler routine.

virtual NVSG_API void handleBillboard ( const nvsg::Billboard * p ) [protected, virtual]

Routine to handle a Billboard node while traversing the scene graph.

This routine gets called for each Billboard object that will be visited while traversing the scene graph. The currently visited Billboard object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Billboard object.

Reimplemented in WRLLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, GeoNodeCombineTraverser, GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODCombineTraverser, LODEliminateTraverser, ModelViewTraverser, RayIntersectTraverser, RenderTraverser, SearchTraverser, SwitchToGroupTraverser, and TransformCombineTraverser.

virtual NVSG_API void handleGeoNode ( const nvsg::GeoNode * p ) [protected, virtual]

Routine to handle a GeoNode while traversing the scene graph.

This routine gets called for each GeoNode object that will be visited while traversing the scene graph. The currently visited GeoNode object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited GeoNode object.

Reimplemented in NVBLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, CullTraverser, DestrippingTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, SearchTraverser, SmoothTraverser, StateSetUnifyTraverser, StrippingTraverser, and TriangulateTraverser.

virtual NVSG_API void handleGroup ( const nvsg::Group * p ) [protected, virtual]

Routine to handle a Group node while traversing the scene graph.

This routine gets called for each Group object that will be visited while traversing the scene graph. The currently visited Group object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

During child traversal you must not change the number or the position of children. Overload and use postTraverseGroup() for this.

Parameters:
p Points to the currently visited Group object.

Reimplemented in WRLLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, GeoNodeCombineTraverser, GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODCombineTraverser, LODEliminateTraverser, RayIntersectTraverser, SearchTraverser, SwitchToGroupTraverser, and TransformCombineTraverser.

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.

This routine gets called for each LOD object that will be visited while traversing the scene graph. The currently visited LOD object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited LOD object.

Reimplemented in NVBLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODEliminateTraverser, ModelViewTraverser, RayIntersectTraverser, SearchTraverser, and SwitchToGroupTraverser.

virtual NVSG_API void handleSwitch ( const nvsg::Switch * p ) [protected, virtual]

Routine to handle a Switch node while traversing the scene graph.

This routine gets called for each Switch object that will be visited while traversing the scene graph. The currently visited Switch object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Switch object.

Reimplemented in NVBLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODEliminateTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleTransform ( const nvsg::Transform * p ) [protected, virtual]

Routine to handle a Transform node while traversing the scene graph.

This routine gets called for each Transform object that will be visited while traversing the scene graph. The currently visited Transform object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Transform object.

Reimplemented in WRLLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, CullTraverser, GeoNodeCombineTraverser, GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODCombineTraverser, LODEliminateTraverser, ModelViewTraverser, RayIntersectTraverser, RenderTraverser, SearchTraverser, SwitchToGroupTraverser, and TransformCombineTraverser.

virtual NVSG_API void handleAnimatedTransform ( const nvsg::AnimatedTransform * p ) [protected, virtual]

Routine to handle a AnimatedTransform node while traversing the scene graph.

This routine gets called for each AnimatedTransform object that will be visited while traversing the scene graph. The currently visited AnimatedTransform object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited AnimatedTransform object.

Reimplemented in WRLLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, GeoNodeCombineTraverser, GeoNodeUnifyTraverser, GroupEliminateTraverser, IdentityToGroupTraverser, LODCombineTraverser, LODEliminateTraverser, ModelViewTraverser, RayIntersectTraverser, SearchTraverser, SwitchToGroupTraverser, and TransformCombineTraverser.

virtual NVSG_API void handleDirectedLight ( const nvsg::DirectedLight * p ) [protected, virtual]

Routine to handle a DirectedLight node while traversing the scene graph.

This routine gets called for each DirectedLight object that will be visited while traversing the scene graph. The currently visited DirectedLight object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited DirectedLight object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handlePointLight ( const nvsg::PointLight * p ) [protected, virtual]

Routine to handle a PointLight node while traversing the scene graph.

This routine gets called for each PointLight object that will be visited while traversing the scene graph. The currently visited PointLight object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited PointLight object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleSpotLight ( const nvsg::SpotLight * p ) [protected, virtual]

Routine to handle a SpotLight node while traversing the scene graph.

This routine gets called for each SpotLight object that will be visited while traversing the scene graph. The currently visited SpotLight object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited SpotLight object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleQuadMeshes ( const nvsg::QuadMeshes * p ) [protected, virtual]

Routine to handle a QuadMeshes object while traversing the scene graph.

This routine gets called for each QuadMeshes object that will be visited while traversing the scene graph. The currently visited QuadMeshes object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited QuadMeshes object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Routine to handle a Quads object while traversing the scene graph.

This routine gets called for each Quads object that will be visited while traversing the scene graph. The currently visited Quads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Quads object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, SearchTraverser, SmoothTraverser, StrippingTraverser, and TriangulateTraverser.

virtual NVSG_API void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Routine to handle a AnimatedQuads object while traversing the scene graph.

This routine gets called for each AnimatedQuads object that will be visited while traversing the scene graph. The currently visited AnimatedQuads object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited AnimatedQuads object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, RayIntersectTraverser, SearchTraverser, TriangulateTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Routine to handle a QuadStrips object while traversing the scene graph.

This routine gets called for each QuadStrips object that will be visited while traversing the scene graph. The currently visited QuadStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited QuadStrips object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, DestrippingTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, SearchTraverser, SmoothTraverser, and TriangulateTraverser.

virtual NVSG_API void handleTriangles ( const nvsg::Triangles * p ) [protected, virtual]

Routine to handle a Triangles object while traversing the scene graph.

This routine gets called for each Triangles object that will be visited while traversing the scene graph. The currently visited Triangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Triangles object.

Reimplemented in NVBLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, SearchTraverser, SmoothTraverser, and StrippingTraverser.

virtual NVSG_API void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Routine to handle a AnimatedTriangles object while traversing the scene graph.

This routine gets called for each AnimatedTriangles object that will be visited while traversing the scene graph. The currently visited AnimatedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited AnimatedTriangles object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, RayIntersectTraverser, SearchTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Routine to handle a SkinnedTriangles object while traversing the scene graph.

This routine gets called for each SkinnedTriangles object that will be visited while traversing the scene graph. The currently visited SkinnedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited SkinnedTriangles object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, RayIntersectTraverser, SearchTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleTriFans ( const nvsg::TriFans * p ) [protected, virtual]

Routine to handle a TriFans object while traversing the scene graph.

This routine gets called for each TriFans object that will be visited while traversing the scene graph. The currently visited TriFans object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited TriFans object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, DestrippingTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, SearchTraverser, and SmoothTraverser.

virtual NVSG_API void handleTriStrips ( const nvsg::TriStrips * p ) [protected, virtual]

Routine to handle a TriStrips object while traversing the scene graph.

This routine gets called for each TriStrips object that will be visited while traversing the scene graph. The currently visited TriStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited TriStrips object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, DestrippingTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, SearchTraverser, and SmoothTraverser.

virtual NVSG_API void handleLines ( const nvsg::Lines * p ) [protected, virtual]

Routine to handle a Lines object while traversing the scene graph.

This routine gets called for each Lines object that will be visited while traversing the scene graph. The currently visited Lines object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Lines object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleLineStrips ( const nvsg::LineStrips * p ) [protected, virtual]

Routine to handle a LineStrips object while traversing the scene graph.

This routine gets called for each LineStrips object that will be visited while traversing the scene graph. The currently visited LineStrips object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited LineStrips object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, DestrippingTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handlePoints ( const nvsg::Points * p ) [protected, virtual]

Routine to handle a Points object while traversing the scene graph.

This routine gets called for each Points object that will be visited while traversing the scene graph. The currently visited Points object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Points object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, PrimitiveSetCombineTraverser, PrimitiveSetUnifyTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleShape ( const nvsg::Shape * p ) [protected, virtual]

Routine to handle a Shape object while traversing the scene graph.

This routine gets called for each Shape object that will be visited while traversing the scene graph. The currently visited Shape object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p pointer to the currently visited Shape object.

Reimplemented in AnalyzeTraverser.

virtual NVSG_API void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Routine to handle a VertexAttributeSet object while traversing the scene graph.

This routine gets called for each VertexAttributeSet object that will be visited while traversing the scene graph. The currently visited VertexAttributeSet object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, GLTraverser, NormalizeTraverser, and VertexUnifyTraverser.

virtual NVSG_API void handleStateSet ( const nvsg::StateSet * p ) [protected, virtual]

Routine to handle a StateSet object while traversing the scene graph.

This routine gets called for each StateSet object that will be visited while traversing the scene graph. The currently visited StateSet object is pointed to by p. The base implementation ensures that the currently active StateVariant will be traversed. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited StateSet object.

Reimplemented in NVBLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, PrimitiveSetCombineTraverser, RayIntersectTraverser, SearchTraverser, and StateSetUnifyTraverser.

virtual NVSG_API void handleStateVariant ( const nvsg::StateVariant * p ) [protected, virtual]

Routine to handle a StateVariant object while traversing the scene graph.

This routine gets called for each StateVariant object that will be visited while traversing the scene graph. The currently visited StateVariant object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p currently visited StateVariant

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RenderTraverser, SearchTraverser, and StateSetUnifyTraverser.

virtual NVSG_API void handleStatePass ( const nvsg::StatePass * p ) [protected, virtual]

Routine to handle a StatePass object while traversing the scene graph.

This routine gets called for each StatePass object that will be visited while traversing the scene graph. The currently visited StatePass object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p currently visited StatePass

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, SearchTraverser, and StateSetUnifyTraverser.

virtual NVSG_API void handleBitmap ( const nvsg::Bitmap * p ) [protected, virtual]

Routine to handle a Bitmap.

This routine gets called for each Bitmap object that will be visited after traversing the scene graph. The currently visited Bitmap object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Bitmap object.

Reimplemented in GLTraverser.

virtual NVSG_API void handleBlendAttribute ( const nvsg::BlendAttribute * p ) [protected, virtual]

Routine to handle a BlendAttribute attribute while traversing the scene graph.

This routine gets called for each BlendAttribute object that will be visited while traversing the scene graph. The currently visited BlendAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited BlendAttribute object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleCgFx ( const nvsg::CgFx * p ) [protected, virtual]

Routine to handle a CgFx attribute while traversing the scene graph.

This routine gets called for each CgFx object that will be visited while traversing the scene graph. The currently visited CgFx object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited CgFx object.

Reimplemented in NVBLoadTraverser, NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, AppTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleDepthAttribute ( const nvsg::DepthAttribute * p ) [protected, virtual]

Routine to handle a DepthAttribute attribute while traversing the scene graph.

This routine gets called for each DepthAttribute object that will be visited while traversing the scene graph. The currently visited DepthAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited DepthAttribute object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleFaceAttribute ( const nvsg::FaceAttribute * p ) [protected, virtual]

Routine to handle a FaceAttribute attribute while traversing the scene graph.

This routine gets called for each FaceAttribute object that will be visited while traversing the scene graph. The currently visited FaceAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited FaceAttribute object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, RayIntersectTraverser, and SearchTraverser.

virtual NVSG_API void handleLineAttribute ( const nvsg::LineAttribute * p ) [protected, virtual]

Routine to handle a LineAttribute attribute while traversing the scene graph.

This routine gets called for each LineAttribute object that will be visited while traversing the scene graph. The currently visited LineAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited LineAttribute object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleMapArray ( const nvsg::MapArray * p ) [protected, virtual]

Routine to handle a MapArray.

This routine gets called for each MapArray object that will be visited after traversing the scene graph. The currently visited MapArray object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited MapArray object.

Reimplemented in RenderTraverser.

virtual NVSG_API void handleMapElement ( const nvsg::MapElement * p ) [protected, virtual]

Routine to handle a MapElement.

This routine gets called for each MapElement object that will be visited after traversing the scene graph. The currently visited MapElement object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited MapElement object.

Reimplemented in RenderTraverser.

virtual NVSG_API void handleMapList ( const nvsg::MapList * p ) [protected, virtual]

Routine to handle a MapList.

This routine gets called for each MapList object that will be visited after traversing the scene graph. The currently visited MapList object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited MapList object.

Reimplemented in GLTraverser.

virtual NVSG_API void handleMapMatrix ( const nvsg::MapMatrix * p ) [protected, virtual]

Routine to handle a MapMatrix.

This routine gets called for each MapMatrix object that will be visited after traversing the scene graph. The currently visited MapMatrix object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited MapMatrix object.

Reimplemented in RenderTraverser.

virtual NVSG_API void handleMaterial ( const nvsg::Material * p ) [protected, virtual]

Routine to handle a Material attribute while traversing the scene graph.

This routine gets called for each Material object that will be visited while traversing the scene graph. The currently visited Material object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Material object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handlePointAttribute ( const nvsg::PointAttribute * p ) [protected, virtual]

Routine to handle a PointAttribute attribute while traversing the scene graph.

This routine gets called for each PointAttribute object that will be visited while traversing the scene graph. The currently visited PointAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited PointAttribute object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleTextureAttribute ( const nvsg::TextureAttribute * p ) [protected, virtual]

Routine to handle a TextureAttribute attribute while traversing the scene graph.

This routine gets called for each TextureAttribute object that will be visited while traversing the scene graph. The currently visited TextureAttribute object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited TextureAttribute object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, SearchTraverser, and StateSetUnifyTraverser.

virtual NVSG_API void handleTextureAttributeItem | ( | const nvsg::TextureAttributeItem * | p,
 |  | size_t | tu
 | ) | [protected, virtual]

Routine to handle a TextureAttributeItem object while traversing the scene graph.

This routine gets called for each TextureAttributeItem object that will be visited while traversing the scene graph. The currently visited TextureAttributeItem object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p | Points to the currently visited TextureAttributeItem object.
tu | Specifies the zero based index of the texture unit to bind the item to.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, and AnalyzeTraverser.

virtual NVSG_API void handleParallelCamera | ( | const nvsg::ParallelCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Routine to handle a ParallelCamera object while traversing the scene graph.

This routine gets called for each ParallelCamera object that will be visited while traversing the scene graph. The currently visited ParallelCamera object is pointed to by p. If the root node pointed to by root is valid (that is, root is not a null pointer), this function traverses the root node after the camera settings have been evaluated. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p | Points to the currently visited ParallelCamera object.
root | If valid, points to the root node to be traversed with the actual camera settings.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ModelViewTraverser, RenderTraverser, and SearchTraverser.

virtual NVSG_API void handlePerspectiveCamera | ( | const nvsg::PerspectiveCamera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

Routine to handle a PerspectiveCamera object while traversing the scene graph.

This routine gets called for each PerspectiveCamera object that will be visited while traversing the scene graph. The currently visited PerspectiveCamera object is pointed to by p. If the root node pointed to by root is valid (that is, root is not a null pointer), this function traverses the root node after the camera settings have been evaluated. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p | Points to the currently visited PerspectiveCamera object.
root | If valid, points to the root node to be traversed with the actual camera settings.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, ModelViewTraverser, RenderTraverser, and SearchTraverser.

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.

This routine gets called for each FramedAnimation<Trafo> object that will be visited while traversing the scene graph. The currently visited FramedAnimation<Trafo> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Animation object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleFramedVNVectorAnimation ( const nvsg::FramedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Routine to handle a FramedAnimation<VNVector> object while traversing the scene graph.

This routine gets called for each FramedAnimation<VNVector> object that will be visited while traversing the scene graph. The currently visited FramedAnimation<VNVector> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Animation object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

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.

This routine gets called for each LinearInterpolatedAnimation<Trafo> object that will be visited while traversing the scene graph. The currently visited LinearInterpolatedAnimation<Trafo> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Animation object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleLinearInterpolatedVNVectorAnimation ( const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > * p ) [protected, virtual]

Routine to handle a LinearInterpolatedAnimation<VNVector> object while traversing the scene graph.

This routine gets called for each LinearInterpolatedAnimation<VNVector> object that will be visited while traversing the scene graph. The currently visited LinearInterpolatedAnimation<VNVector> object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p Points to the currently visited Animation object.

Reimplemented in NBFSaveTraverser, NVSGSaveTraverser, AnalyzeTraverser, and SearchTraverser.

virtual NVSG_API void handleHighlightBox | ( | const nvsg::HighlightBox * | p,
 |  | const nvsg::PrimitiveSet * | primitive
 | ) | [protected, virtual]

Routine to handle a HighlightBox object while traversing the scene graph.

This routine gets called for each HighlightBox object that will be visited while traversing the scene graph. The currently visited Highlight object is pointed to by p.

Remarks:
A HighlighBox always is attached to its corresponding PrimitiveSet object as a HighlightObject .
Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p | Points to the currently visited HighlightBox object.
primitive | Points to the corresponding PrimitiveSet object.

Reimplemented in AppTraverser.

virtual NVSG_API void handleHighlightEdges | ( | const nvsg::HighlightEdges * | p,
 |  | const nvsg::PrimitiveSet * | primitive
 | ) | [protected, virtual]

Routine to handle a HighlightEdges object while traversing the scene graph.

This routine gets called for each HighlightEdges object that will be visited while traversing the scene graph. The currently visited Highlight object is pointed to by p.

Remarks:
A HighlighEdges always is attached to its corresponding PrimitiveSet object as a HighlightObject .
Note:
The behavior is undefined if p points to an invalid location.
Parameters:
p | Points to the currently visited HighlightEdges object.
primitive | Points to the corresponding PrimitiveSet object.

virtual NVSG_API bool preTraverseRoot | ( | const nvsg::Camera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

This function will be called from the framework immediately before the scene graph is traversed.

If the function returns false, further traversing will be skipped.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately before the scene graph is traversed.
Parameters:
p | Camera that will be applied while traversing the scene graph.
root | Root node to start traversing from.

Reimplemented in FrustumCullTraverser, and ModelViewTraverser.

virtual NVSG_API void postTraverseRoot | ( | const nvsg::Camera * | p,
 |  | const nvsg::Node * | root
 | ) | [protected, virtual]

This function will be called from the framework immediately after the scene graph has been traversed.

remarks Custom traversers can override this function for any tasks that need to be done immediately after the scene graph has been traversed.

Parameters:
p | Camera that was applied while traversing the scene graph.
root | Root node were traversing has been started from.

virtual NVSG_API bool preTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

This function will be called from the framework immediately before a Group is traversed.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately before the Group pointed to by p is traversed.
Parameters:
p Points to the Group that will be traversed immediately after this call.

Reimplemented in AnalyzeTraverser, RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API void postTraverseGroup ( const nvsg::Group * p ) [protected, virtual]

This function will be called from the framework immediately after a Group has been traversed.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately after the Group pointed to by p has been traversed.
Parameters:
p Points to the Group that was traversed immediately before this call.

Reimplemented in AnalyzeTraverser, RayIntersectTraverser, and RenderTraverser.

virtual NVSG_API bool preTraverseDrawables | ( | const nvsg::GeoNode * | p,
 |  | size_t | i
 | ) | [protected, virtual]

This function will be called from the framework immediately before coherent Drawables will be traversed.

The function is called for the Drawables belonging to the i-th geometry of the specified GeoNode. If the function returns false, the traversal of the specified Drawables will be skipped.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately before coherent Drawables will be traversed.
Returns:
The default implementation always returns true.
Parameters:
p | The GeoNode which owns the Drawables.
i | Geometry index to the coherent Drawables.

Reimplemented in RenderTraverser.

virtual NVSG_API void postTraverseDrawables | ( | const nvsg::GeoNode * | p,
 |  | size_t | i
 | ) | [protected, virtual]

This function will be called from the framework immediately after coherent Drawables have been traversed.

The function is called for the Drawables belonging to the i-th geometry of the specified GeoNode.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately after coherent Drawables have been traversed.
Parameters:
p | The GeoNode which owns the Drawables.
i | Geometry index to the coherent Drawables.

Reimplemented in RenderTraverser.

virtual NVSG_API bool preTraverseDrawable ( const nvsg::Drawable * p ) [protected, virtual]

This function will be called from the framework immediately before a single Drawable is traversed.

If the function returns false, further traversing will be skipped.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately before the Drawable is traversed.
Parameters:
p Drawable that is going to be traversed

virtual NVSG_API void postTraverseDrawable ( const nvsg::Drawable * p ) [protected, virtual]

This function will be called from the framework immediately after a Drawable has been traversed.

Remarks:
Custom traversers can override this function for any tasks that need to be done immediately after the Drawable pointed to by p has been traversed.
Parameters:
p Drawable that has been traversed immediately before this call.

virtual NVSG_API void traverseHighlightObject | ( | const nvsg::HighlightObject * | p,
 |  | const nvsg::PrimitiveSet * | primitive
 | ) | [protected, virtual]

This function will be called from the framework when a HighlightObject is visited.

remarks Custom traversers can override this function for special tasks that need to be performed when visiting a HighlightObject object.

Parameters:
p | HighlightObject to traverse
primitive | corresponding PrimitiveSet

virtual NVSG_API void traverseLight ( const nvsg::LightSource * p ) [protected, virtual]

This function will be called from the framework when a LightSource node is visited.

remarks Custom traversers can override this function for special tasks that need to be performed when visiting a LightSource node.

Parameters:
p Points to the currently visited LightSource node.

Reimplemented in AppTraverser, CullTraverser, and RenderTraverser.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * p ) [protected, virtual]

This function will be called from the framework when a PrimitiveSet is visited.

remarks Custom traversers can override this function for special tasks that need to be performed when visiting a PrimitiveSet object.

Parameters:
p PrimitiveSet to traverse

Reimplemented in CullTraverser, RenderTraverser, and VertexAttributeSetUnifyTraverser.

virtual NVSG_API void preTraverseMap | ( | const nvsg::MapArray * | p,
 |  | size_t | index
 | ) | [protected, virtual]

This function will be called from the framework before a Map as part of a MapArray is traversed.

Parameters:
p | MapArray currently traversed
index | index of Map to be traversed

Reimplemented in RenderTraverser.

virtual NVSG_API void postTraverseMap | ( | const nvsg::MapArray * | p,
 |  | size_t | index
 | ) | [protected, virtual]

This function will be called from the framework after a Map as part of a MapArray has been traversed.

Parameters:
p | MapArray currently traversed
index | index of Map that has been traversed

virtual NVSG_API void preTraverseMap | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col,
 |  | size_t | row
 | ) | [protected, virtual]

This function will be called from the framework before a Map as part of a MapMatrix is traversed.

The default handler for a MapMatrix traverses it's Maps in row-column order. That is for each column, it traverses each row. Before traversing one of it's maps, this function is called with the corresponding col and row indices.

Parameters:
p | MapMatrix currently traversed
col | column of the MapMatrix currently traversed
row | index of the Map in the column col to be traversed

Reimplemented in RenderTraverser.

virtual NVSG_API void postTraverseMap | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col,
 |  | size_t | row
 | ) | [protected, virtual]

This function will be called from the framework after a Map as part of a MapMatrix is traversed.

The default handler for a MapMatrix traverses it's Maps in row-column order. That is for each column, it traverses each row. After traversing one of it's maps, this function is called with the corresponding col and row indices.

Parameters:
p | MapMatrix currently traversed
col | column of the MapMatrix currently traversed
row | index of the Map in the column col that has been traversed

virtual NVSG_API void preTraverseMapColumn | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col
 | ) | [protected, virtual]

This function will be called from the framework before a column of Maps of a MapMatrix is traversed.

The default handler for a MapMatrix traverses it's Maps in row-column order. That is for each column, it traverses each row. Before traversing one of it's columns, this function is called with the corresponding col index.

Parameters:
p | MapMatrix currently traversed
col | column index of the MapMatrix to be traversed

Reimplemented in RenderTraverser.

virtual NVSG_API void postTraverseMapColumn | ( | const nvsg::MapMatrix * | p,
 |  | size_t | col
 | ) | [protected, virtual]

This function will be called from the framework after a column of Maps of a MapMatrix is traversed.

The default handler for a MapMatrix traverses it's Maps in row-column order. That is for each column, it traverses each row. After traversing one of it's columns, this function is called with the corresponding col index.

Parameters:
p | MapMatrix currently traversed
col | column index of the MapMatrix that has been traversed

Reimplemented in RenderTraverser.

T* beginEdit ( const T * obj ) const [inline, protected]

Get a writable pointer to a constant object.

While traversing, all modifications of objects have to be embraced by beginEdit/endEdit.

Returns:
A non-constant pointer to the object.
Parameters:
obj object to get a non-constant pointer to

const T* endEdit ( const T * obj ) const [inline, protected]

End the editing operation on a constant object.

While traversing, all modifications of objects have to be embraced by beginEdit/endEdit.

Returns:
A constant pointer to the object.
Parameters:
obj object to end editing operations on

Member Data Documentation

std::stack<size_t> m_lodStack [protected]

Holds the index of the current LOD level.

std::stack<const nvsg::CullData *> m_cullStack [protected]

Holds the cull data corresponding to the traversed tree.

const nvsg::ViewState* m_viewState [protected]

Always NULL in the base class. Derived classes can set it.

nvutil::ProblemLog m_problemLog [protected]

All problems during the construction of the < traverser go here.

const nvsg::StateSet* m_nullStateSet [protected]

Serves default state handling.

bool volatile m_interrupt [protected]

Flag to assign an interrupt request.

bool m_interrupted [protected]

Flag to assign whether the current traversal has been interrupted.

The documentation for this class was generated from the following file:
  • Traverser.h
Generated on Fri Aug 4 08:39:49 2006 for NVSGSDK by NVIDIA


Member List

Traverser Member List

This is the complete list of members for Traverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | Traverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
Generated on Fri Aug 4 08:39:49 2006 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 Fri Aug 4 08:38:53 2006 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, 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 Fri Aug 4 08:38:53 2006 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

virtual NVSG_API const Triangles * | clone () const
Create a new Triangles by copying from this.

NVSG_API bool | hasFaces () const
Query if this Triangles has faces.

NVSG_API size_t | 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, size_t numFaces)
Set the faces of this Triangles.

NVSG_API void | setFaces (size_t pos, const Face3 *faces, size_t numFaces)
Set a subset of faces of this Triangles.

NVSG_API Triangles & | operator= (const Triangles &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const Triangles * | create ()
Create a Triangles.

NVSG_API const Triangles * | createFromBase (const IndependentPrimitiveSet &rhs)
Create a Triangles by copying from an IndependentPrimitiveSet.

NVSG_API const Triangles * | createFromBase (const PrimitiveSet &rhs)
Create a Triangles by copying from a PrimitiveSet.

Protected Member Functions

NVSG_API | Triangles ()
Protected constructor to prevent explicit creation.

NVSG_API | Triangles (const IndependentPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Triangles (const PrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | Triangles (const Triangles &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~Triangles ()
Protected destructor to prevent explicit creation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const Triangles *t, size_t tu=0, size_t tg=1, size_t bn=2)
Generate tangents and binormals for a Triangles.

NVSG_API void | generateNormals (const Triangles *q)
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 ( ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside Triangles::create.

NVSG_API Triangles ( const IndependentPrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to use as a base of the new Triangles
Remarks:
This constructor is never used explicitly, but only inside Triangles::createFromBase.
See also:
IndependentPrimitiveSet

NVSG_API Triangles ( const PrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant PrimitiveSet to use as a base of the new Triangles
Remarks:
This constructor is never used explicitly, but only inside Triangles::createFromBase.
See also:
PrimitiveSet

NVSG_API Triangles ( const Triangles & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant Triangles to copy from
Remarks:
This constructor is never used explicitly, but only inside Triangles::create.

virtual NVSG_API ~Triangles ( ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the Triangles is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const Triangles* create ( ) [static]

Create a Triangles.

Returns:
A pointer to a constant Triangles.
Remarks:
Per default a Triangles is empty.

Reimplemented in SkinnedTriangles.

NVSG_API const Triangles* createFromBase ( const IndependentPrimitiveSet & rhs ) [static]

Create a Triangles by copying from an IndependentPrimitiveSet.

Parameters:
rhs A reference to the constant IndependentPrimitiveSet to copy from
Returns:
A pointer to a constant Triangles.
Remarks:
All the data from the IndependentPrimitiveSet rhs is used as the base information for the newly created Triangles. The indices provided with rhs are interpreted then as triples defining triangles.
See also:
IndependentPrimitiveSet

NVSG_API const Triangles* createFromBase ( const PrimitiveSet & rhs ) [static]

Create a Triangles by copying from a PrimitiveSet.

Parameters:
rhs A reference to the constant PrimitiveSet to copy from
Returns:
A pointer to a constant Triangles.
Remarks:
All the data from the PrimitiveSet rhs is used as the base information for the newly created Triangles. But there are no indices provided, so there are no triangles in the new Triangles object.
See also:
IndependentPrimitiveSet

virtual NVSG_API const Triangles* clone ( ) const [virtual]

Create a new Triangles by copying from this.

Returns:
A pointer to a constant Triangles.
Remarks:
The newly created Triangles is an exact copy of this.

Implements IndependentPrimitiveSet.

Reimplemented in AnimatedTriangles, and SkinnedTriangles.

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

size_t 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,
 |  | size_t | 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 | ( | size_t | pos,
 |  | const Face3 * | faces,
 |  | size_t | 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 | ( | const Triangles * | t,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | 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 ( const Triangles * q ) [related]

Generate normals for a Triangles.

Parameters:
q 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 Fri Aug 4 08:38:57 2006 for NVSGSDK by NVIDIA


Member List

Triangles Member List

This is the complete list of members for Triangles, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere() const | IndependentPrimitiveSet | [protected, virtual]
calculateTangentSpace(const Triangles *t, size_t tu=0, size_t tg=1, size_t bn=2) | Triangles | [related]
clone() const | Triangles | [virtual]
create() | Triangles | [static]
createFromBase(const IndependentPrimitiveSet &rhs) | Triangles | [static]
createFromBase(const PrimitiveSet &rhs) | Triangles | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const Triangles *q) | Triangles | [related]
getBoundingSphere(void) const | Drawable |
getDataID() const | IndependentPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFaces() const | Triangles | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getIndices() const | IndependentPrimitiveSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFaces() const | Triangles | [inline]
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfIndices() const | IndependentPrimitiveSet | [inline]
getNumberOfOwners(void) const | Drawable | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasFaces() const | Triangles | [inline]
hasIndices() const | IndependentPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected]
IndependentPrimitiveSet(const PrimitiveSet &rhs) | IndependentPrimitiveSet | [explicit, protected]
IndependentPrimitiveSet(const IndependentPrimitiveSet &rhs) | IndependentPrimitiveSet | [protected]
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared() const | IndependentPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | IndependentPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setFaces(const Face3 *faces, size_t numFaces) | Triangles | [inline]
setFaces(size_t pos, const Face3 *faces, size_t numFaces) | Triangles | [inline]
setIndices(const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setIndices(size_t pos, const unsigned int *indices, size_t numIndices) | IndependentPrimitiveSet |
setName(const std::string &name) | Object |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
theAllocator typedef | IAllocator |
Triangles() | Triangles | [protected]
Triangles(const IndependentPrimitiveSet &rhs) | Triangles | [protected]
Triangles(const PrimitiveSet &rhs) | Triangles | [protected]
Triangles(const Triangles &rhs) | Triangles | [protected]
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~IndependentPrimitiveSet() | IndependentPrimitiveSet | [protected, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Triangles() | Triangles | [protected, virtual]
Generated on Fri Aug 4 08:38:57 2006 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 | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Handle an AnimatedQuads object.

virtual NVSG_API void | handleGeoNode (const nvsg::GeoNode *p)
Handle a GeoNode object.

virtual NVSG_API void | handleQuads (const nvsg::Quads *p)
Handle a Quads object.

virtual NVSG_API void | handleQuadStrips (const nvsg::QuadStrips *p)
Handle a QuadStrips object.

Detailed Description

Traverser that converts all flavors of quads to triangles.

Converts AnimatedQuads to AnimatedTriangles, 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 handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Handle an AnimatedQuads object.

Replaces an AnimatedQuads object by an AnimatedTriangles object.

Parameters:
p AnimatedQuads to handle

Reimplemented from Traverser.

virtual NVSG_API void handleGeoNode ( const 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 Traverser.

virtual NVSG_API void handleQuads ( const nvsg::Quads * p ) [protected, virtual]

Handle a Quads object.

Replaces a Quads object by a Triangles object.

Parameters:
p Quads to handle

Reimplemented from Traverser.

virtual NVSG_API void handleQuadStrips ( const nvsg::QuadStrips * p ) [protected, virtual]

Handle a QuadStrips object.

Replaces a QuadStrips object by a TrianglesStrips object.

Parameters:
p QuadStrips to handle

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • TriangulateTraverser.h
Generated on Fri Aug 4 08:39:50 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | Traverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | TriangulateTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | TriangulateTraverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | TriangulateTraverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | TriangulateTraverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
TriangulateTraverser(void) | TriangulateTraverser |
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
~TriangulateTraverser(void) | TriangulateTraverser | [protected, virtual]
Generated on Fri Aug 4 08:39:50 2006 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

virtual NVSG_API const TriFans * | clone () const
Create a new TriFans by copying from this.

NVSG_API TriFans & | operator= (const TriFans &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const TriFans * | create (void)
Create a TriFans.

NVSG_API const TriFans * | createFromBase (const StrippedPrimitiveSet &rhs)
Create a TriFans by copying from an StrippedPrimitiveSet.

Protected Member Functions

NVSG_API | TriFans (void)
Protected constructor to prevent explicit creation.

NVSG_API | TriFans (const StrippedPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | TriFans (const TriFans &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~TriFans (void)
Protected destructor to prevent explicit creation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const TriFans *tf, size_t tu=0, size_t tg=1, size_t bn=2)
Generate tangents and binormals for a TriFans.

NVSG_API void | generateNormals (const 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 ( void ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside TriFans::create.

NVSG_API TriFans ( const StrippedPrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to use as a base of the new TriFans
Remarks:
This constructor is never used explicitly, but only inside TriFans::createFromBase.
See also:
StrippedPrimitiveSet

NVSG_API TriFans ( const TriFans & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant TriFans to copy from
Remarks:
This constructor is never used explicitly, but only inside TriFans::create.

virtual NVSG_API ~TriFans ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the TriFans is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const TriFans* create ( void ) [static]

Create a TriFans.

Returns:
A pointer to a constant TriFans.
Remarks:
By default, a TriFans is empty.

NVSG_API const TriFans* createFromBase ( const StrippedPrimitiveSet & rhs ) [static]

Create a TriFans by copying from an StrippedPrimitiveSet.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to copy from
Returns:
A pointer to a constant TriFans.
Remarks:
All the data from the StrippedPrimitiveSet rhs is used as the base information for the newly created TriFans. The indices provided with rhs are then interpreted as a series of triangle fans.
See also:
StrippedPrimitiveSet

virtual NVSG_API const TriFans* clone ( ) const [virtual]

Create a new TriFans by copying from this.

Returns:
A pointer to a constant TriFans.
Remarks:
The newly created TriFans is an exact copy of this.

Implements StrippedPrimitiveSet.

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 | ( | const TriFans * | tf,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | bn = 2
 | ) | [related]

Generate tangents and binormals for a TriFans.

Parameters:
tf | A pointer to the constant 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 ( const TriFans * q ) [related]

Generate normals for a TriFans.

Parameters:
q A pointer to the constant TriFans to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • TriFans.h
Generated on Fri Aug 4 08:38:58 2006 for NVSGSDK by NVIDIA


Member List

TriFans Member List

This is the complete list of members for TriFans, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere(void) const | StrippedPrimitiveSet | [protected, virtual]
calculateTangentSpace(const TriFans *tf, size_t tu=0, size_t tg=1, size_t bn=2) | TriFans | [related]
clone() const | TriFans | [virtual]
create(void) | TriFans | [static]
createFromBase(const StrippedPrimitiveSet &rhs) | TriFans | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const TriFans *q) | TriFans | [related]
getBoundingSphere(void) const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setStrips(const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setStrips(size_t pos, const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
theAllocator typedef | IAllocator |
TriFans(void) | TriFans | [protected]
TriFans(const StrippedPrimitiveSet &rhs) | TriFans | [protected]
TriFans(const TriFans &rhs) | TriFans | [protected]
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected, virtual]
~TriFans(void) | TriFans | [protected, virtual]
Generated on Fri Aug 4 08:38:58 2006 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

virtual NVSG_API const TriStrips * | clone () const
Create a new TriStrips by copying from this.

NVSG_API TriStrips & | operator= (const TriStrips &rhs)
Assignment operator.

Static Public Member Functions

NVSG_API const TriStrips * | create (void)
Create a TriStrips.

NVSG_API const TriStrips * | createFromBase (const StrippedPrimitiveSet &rhs)
Create a TriStrips by copying from an StrippedPrimitiveSet.

Protected Member Functions

NVSG_API | TriStrips (void)
Protected constructor to prevent explicit creation.

NVSG_API | TriStrips (const StrippedPrimitiveSet &rhs)
Protected partial copy constructor to prevent explicit creation.

NVSG_API | TriStrips (const TriStrips &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~TriStrips (void)
Protected destructor to prevent explicit creation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | calculateTangentSpace (const TriStrips *ts, size_t tu=0, size_t tg=1, size_t bn=2)
Generate tangents and binormals for a TriStrips.

NVSG_API void | generateNormals (const 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 ( void ) [protected]

Protected constructor to prevent explicit creation.

Remarks:
This constructor is never used explicitly, but only inside TriStrips::create.

NVSG_API TriStrips ( const StrippedPrimitiveSet & rhs ) [protected]

Protected partial copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to use as a base of the new TriStrips
Remarks:
This constructor is never used explicitly, but only inside TriStrips::createFromBase.
See also:
StrippedPrimitiveSet

NVSG_API TriStrips ( const TriStrips & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Parameters:
rhs A reference to the constant TriStrips to copy from
Remarks:
This constructor is never used explicitly, but only inside TriStrips::create.

virtual NVSG_API ~TriStrips ( void ) [protected, virtual]

Protected destructor to prevent explicit creation.

Remarks:
The destructor is never used explicitly, but only when the reference count of the TriStrips is decremented to zero.
See also:
addRef, removeRef

Member Function Documentation

NVSG_API const TriStrips* create ( void ) [static]

Create a TriStrips.

Returns:
A pointer to a constant TriStrips.
Remarks:
By default, a TriStrips is empty.

NVSG_API const TriStrips* createFromBase ( const StrippedPrimitiveSet & rhs ) [static]

Create a TriStrips by copying from an StrippedPrimitiveSet.

Parameters:
rhs A reference to the constant StrippedPrimitiveSet to copy from
Returns:
A pointer to a constant TriStrips.
Remarks:
All the data from the StrippedPrimitiveSet rhs is used as the base information for the newly created TriStrips. The indices provided with rhs are then interpreted as a series of triangle strips.
See also:
StrippedPrimitiveSet

virtual NVSG_API const TriStrips* clone ( ) const [virtual]

Create a new TriStrips by copying from this.

Returns:
A pointer to a constant TriStrips.
Remarks:
The newly created TriStrips is an exact copy of this.

Implements StrippedPrimitiveSet.

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 | ( | const TriStrips * | ts,
 |  | size_t | tu = 0,
 |  | size_t | tg = 1,
 |  | size_t | bn = 2
 | ) | [related]

Generate tangents and binormals for a TriStrips.

Parameters:
ts | A pointer to the constant 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 ( const TriStrips * q ) [related]

Generate normals for a TriStrips.

Parameters:
q A pointer to the constant TriStrips to create normals for.
See also:
calculateTangentSpace

The documentation for this class was generated from the following file:
  • TriStrips.h
Generated on Fri Aug 4 08:38:59 2006 for NVSGSDK by NVIDIA


Member List

TriStrips Member List

This is the complete list of members for TriStrips, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
attachHighlightObject(const HighlightObject *obj=NULL) | Drawable |
calculateBoundingSphere(void) const | StrippedPrimitiveSet | [protected, virtual]
calculateTangentSpace(const TriStrips *ts, size_t tu=0, size_t tg=1, size_t bn=2) | TriStrips | [related]
clone() const | TriStrips | [virtual]
create(void) | TriStrips | [static]
createFromBase(const StrippedPrimitiveSet &rhs) | TriStrips | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
Drawable(void) | Drawable | [protected]
Drawable(const Drawable &) | Drawable | [protected]
generateNormals(const TriStrips *q) | TriStrips | [related]
getBoundingSphere(void) const | Drawable |
getDataID(void) const | StrippedPrimitiveSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getHighlightObject(void) const | Drawable | [inline]
getIncarnation() const | Object |
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNumberOfFrames(void) const | Drawable | [virtual]
getNumberOfOwners(void) const | Drawable | [inline]
getNumberOfStrips(void) const | StrippedPrimitiveSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | Drawable | [inline]
getStrips() const | StrippedPrimitiveSet | [inline]
getVertexAttributeSet() const | PrimitiveSet | [inline]
hasStrips(void) const | StrippedPrimitiveSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateBoundingSphere(void) | Drawable |
invalidateIncarnation(void) | Drawable | [protected, virtual]
invalidateNumberOfFrames(void) const | Drawable |
isCompatible(const PrimitiveSet *p, bool ignoreNames=true) const | PrimitiveSet |
isDataShared(void) const | StrippedPrimitiveSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | StrippedPrimitiveSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
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::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PrimitiveSet() | PrimitiveSet | [protected]
PrimitiveSet(const PrimitiveSet &rhs) | PrimitiveSet | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setName(const std::string &name) | Object |
setStrips(const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setStrips(size_t pos, const IndexSet *strips, size_t numStrips) | StrippedPrimitiveSet |
setVertexAttributeSet(const VertexAttributeSet *set) | PrimitiveSet |
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected]
StrippedPrimitiveSet(const StrippedPrimitiveSet &rhs) | StrippedPrimitiveSet | [protected]
theAllocator typedef | IAllocator |
TriStrips(void) | TriStrips | [protected]
TriStrips(const StrippedPrimitiveSet &rhs) | TriStrips | [protected]
TriStrips(const TriStrips &rhs) | TriStrips | [protected]
validateIncarnation() const | PrimitiveSet | [protected, virtual]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~Drawable(void) | Drawable | [protected, virtual]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~PrimitiveSet() | PrimitiveSet | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~StrippedPrimitiveSet(void) | StrippedPrimitiveSet | [protected, virtual]
~TriStrips(void) | TriStrips | [protected, virtual]
Generated on Fri Aug 4 08:38:59 2006 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
uint_t | numValues
uint_t | numTweaks
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.

str_t str

Specifies the string value in case of a string parameter.

!< 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.

uint_t tweaks

Specifies the file offset to either the array elements or struct members.

!< In case of an array parameter this specifies the array size. In case of a struct parameter this specifies the number of members.

The documentation for this struct was generated from the following file:
  • NBF.h
Generated on Fri Aug 4 08:37:07 2006 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 (defined in tweak_t) | tweak_t
name | tweak_t
numTweaks (defined in tweak_t) | tweak_t
numValues (defined in tweak_t) | tweak_t
str | tweak_t
tweaks | tweak_t
type (defined in tweak_t) | 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 Fri Aug 4 08:37:07 2006 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 Fri Aug 4 08:40:10 2006 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 Fri Aug 4 08:40:10 2006 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 Fri Aug 4 08:40:10 2006 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 Fri Aug 4 08:40:10 2006 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 );
    const nvsg::StateVariant * sv = p->getVariant( vi );
    // ...
  }
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 Fri Aug 4 08:38:40 2006 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 Fri Aug 4 08:38:40 2006 for NVSGSDK by NVIDIA


Vec2f Class Reference

Vector class with 2 float components. More...

#include <Vec2f.h>

Inheritance diagram for Vec2f:

[legend]
Collaboration diagram for Vec2f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Vec2f (void)
Default constructor.

NVSG_API | Vec2f (float x, float y)
Constructor using two floats.

NVSG_API | Vec2f (const Vecnf< 2 > &v)
Copy constructor.

NVSG_API void | set (float x, float y)
Set this with two float values.

Related Functions

(Note that these are not member functions.)

const Vec2f | operator * (float f, const Vec2f &v)

Detailed Description

Vector class with 2 float components.

Constructor & Destructor Documentation

Vec2f ( void ) [inline]

Default constructor.

For performance reasons no initialization is performed.

Vec2f | ( | float | x,
 |  | float | y
 | ) | [inline]

Constructor using two floats.

A Vec2f with the given values is constructed.

Vec2f ( const Vecnf< 2 > & v ) [inline]

Copy constructor.

Member Function Documentation

void set | ( | float | x,
 |  | float | y
 | ) | [inline]

Set this with two float values.

Friends And Related Function Documentation

const Vec2f operator * | ( | float | f,
 |  | const Vec2f & | v
 | ) | [related]

Multiplication of a scalar with a Vec2f.

Returns:
product of f with v
Parameters:
f | scalar to multiply with
v | Vec2f to multiply

The documentation for this class was generated from the following file:
  • Vec2f.h
Generated on Fri Aug 4 08:37:24 2006 for NVSGSDK by NVIDIA


Member List

Vec2f Member List

This is the complete list of members for Vec2f, including all inherited members.
getPtr(void) const | Vecnf< 2 > |
normalize(void) | Vecnf< 2 > |
operator *(float f, const Vec2f &v) | Vec2f | [related]
nvmath::Vecnf< 2 >::operator *(float f) const | Vecnf< 2 > |
nvmath::Vecnf< 2 >::operator *(double f) const | Vecnf< 2 > |
nvmath::Vecnf< 2 >::operator *(const Vecnf< n > &v) const | Vecnf< 2 > |
operator *=(float f) | Vecnf< 2 > |
operator *=(double f) | Vecnf< 2 > |
operator!=(const Vecnf< n > &v) const | Vecnf< 2 > |
operator+(const Vecnf< n > &v) const | Vecnf< 2 > |
operator+=(const Vecnf< n > &v) | Vecnf< 2 > |
operator-(void) const | Vecnf< 2 > |
operator-(const Vecnf< n > &v) const | Vecnf< 2 > |
operator-=(const Vecnf< n > &v) | Vecnf< 2 > |
operator/(float f) const | Vecnf< 2 > |
operator/(double f) const | Vecnf< 2 > |
operator/=(float f) | Vecnf< 2 > |
operator/=(double f) | Vecnf< 2 > |
operator=(const Vecnf< n > &v) | Vecnf< 2 > |
operator==(const Vecnf< n > &v) const | Vecnf< 2 > |
operator[](size_t i) | Vecnf< 2 > |
operator[](size_t i) const | Vecnf< 2 > |
orthogonalize(const Vecnf< n > &v) | Vecnf< 2 > |
orthonormalize(const Vecnf< n > &v) | Vecnf< 2 > |
set(float x, float y) | Vec2f | [inline]
Vec2f(void) | Vec2f | [inline]
Vec2f(float x, float y) | Vec2f | [inline]
Vec2f(const Vecnf< 2 > &v) | Vec2f | [inline]
Vecnf(void) | Vecnf< 2 > |
Vecnf(const Vecnf< n > &v) | Vecnf< 2 > |
Generated on Fri Aug 4 08:37:24 2006 for NVSGSDK by NVIDIA


Vec3f Class Reference

Vector class with 3 float components. More...

#include <Vec3f.h>

Inheritance diagram for Vec3f:

[legend]
Collaboration diagram for Vec3f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Vec3f (void)
Default constructor.

NVSG_API | Vec3f (float x, float y, float z)
Constructor using three floats.

NVSG_API | Vec3f (const Vecnf< 3 > &v)
Copy constructor.

NVSG_API | Vec3f (const Vecnf< 4 > &v)
Constructor by a Vec4f.

NVSG_API Vec3f & | operator= (const Vec4f &v)
Assignment operator.

NVSG_API const Vec3f | operator- (void) const
Negation operator.

NVSG_API void | set (float x, float y, float z)
Set the Vec3f with three float values.

Related Functions

(Note that these are not member functions.)

Vec3f | normalize (const Vec3f &v)
void | normalize (const std::vector< Vec3f > &vecIn, std::vector< Vec3f > &vecOut)
const Vec3f | operator * (float f, const Vec3f &v)
const Vec3f | operator^ (const Vecnf< 3 > &v0, const Vecnf< 3 > &v1)
bool | areCollinear (const Vec3f &v0, const Vec3f &v1, float epsilon=FLT_EPSILON)
NVSG_API void | smoothNormals (const std::vector< Vec3f > &vertices, const Sphere3f &sphere, float creaseAngle, std::vector< Vec3f > &normals)

Detailed Description

Vector class with 3 float components.

Constructor & Destructor Documentation

NVSG_API Vec3f ( void )

Default constructor.

For performance reasons no initialization is performed.

NVSG_API Vec3f | ( | float | x,
 |  | float | y,
 |  | float | z
 | ) |

Constructor using three floats.

A Vec3f with the given values is constructed.

NVSG_API Vec3f ( const Vecnf< 3 > & v )

Copy constructor.

Parameters:
v Vec3f to copy

NVSG_API Vec3f ( const Vecnf< 4 > & v )

Constructor by a Vec4f.

Ignores fourth component of constructing Vec4f.

Parameters:
v Vec4f to use first three components from

Member Function Documentation

NVSG_API Vec3f& operator= ( const Vec4f & v )

Assignment operator.

Ignores the fourth component of the assigning Vec4f.

Returns:
reference to the assigned Vec3f
Parameters:
v Vec4f to copy first three components from

const Vec3f operator- ( void ) const [inline]

Negation operator.

Returns:
negated Vec3f

Reimplemented from Vecnf< 3 >.

void set | ( | float | x,
 |  | float | y,
 |  | float | z
 | ) | [inline]

Set the Vec3f with three float values.

Friends And Related Function Documentation

Vec3f normalize ( const Vec3f & v ) [related]

Calculate the normalized version of v.

Returns:
normalized version of v
Parameters:
v Vec3f to determine normalized Vec3f from

void normalize | ( | const std::vector< Vec3f > & | vecIn,
 |  | std::vector< Vec3f > & | vecOut
 | ) | [related]

Calculate an array of normalized Vec3f from array of Vec3f.

Parameters:
vecIn | array of Vec3f to normalize
vecOut | array of normalized Vec3f

const Vec3f operator * | ( | float | f,
 |  | const Vec3f & | v
 | ) | [related]

Multiplication of a scalar with a Vec3f.

Returns:
product of f with v
Parameters:
f | scalar to multiply with
v | Vec3f to multiply

const Vec3f operator^ | ( | const Vecnf< 3 > & | v0,
 |  | const Vecnf< 3 > & | v1
 | ) | [related]

Calculation of the cross product of v0 with v1.
The cross product of two Vec3f is a Vec3f that is orthogonal to both arguments

Returns:
cross product of v0 and v1.

bool areCollinear | ( | const Vec3f & | v0,
 |  | const Vec3f & | v1,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test two Vec3f for collinearity.
Two Vec3f are considered to be collinear, if their cross product differs less than epsilon from zero.

Returns:
true if t0 and t1 are collinear, otherwise false
Parameters:
epsilon optional epsilon

NVSG_API void smoothNormals | ( | const std::vector< Vec3f > & | vertices,
 |  | const Sphere3f & | sphere,
 |  | float | creaseAngle,
 |  | std::vector< Vec3f > & | normals
 | ) | [related]

Determine smoothed normals for a set of vertices.
Given some vertices with normals and their bounding sphere, this function calculates smoothed 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.

Parameters:
vertices | vertices to determine smoothed normals for
sphere | bounding sphere of the vertices
creaseAngle | crease angle to follow
normals | in: normals of vertices; out: smoothed normals

The documentation for this class was generated from the following file:
  • Vec3f.h
Generated on Fri Aug 4 08:37:24 2006 for NVSGSDK by NVIDIA


Member List

Vec3f Member List

This is the complete list of members for Vec3f, including all inherited members.
areCollinear(const Vec3f &v0, const Vec3f &v1, float epsilon=FLT_EPSILON) | Vec3f | [related]
getPtr(void) const | Vecnf< 3 > |
normalize(const Vec3f &v) | Vec3f | [related]
normalize(const std::vector< Vec3f > &vecIn, std::vector< Vec3f > &vecOut) | Vec3f | [related]
nvmath::Vecnf< 3 >::normalize(void) | Vecnf< 3 > |
operator *(float f, const Vec3f &v) | Vec3f | [related]
nvmath::Vecnf< 3 >::operator *(float f) const | Vecnf< 3 > |
nvmath::Vecnf< 3 >::operator *(double f) const | Vecnf< 3 > |
nvmath::Vecnf< 3 >::operator *(const Vecnf< n > &v) const | Vecnf< 3 > |
operator *=(float f) | Vecnf< 3 > |
operator *=(double f) | Vecnf< 3 > |
operator!=(const Vecnf< n > &v) const | Vecnf< 3 > |
operator+(const Vecnf< n > &v) const | Vecnf< 3 > |
operator+=(const Vecnf< n > &v) | Vecnf< 3 > |
operator-(void) const | Vec3f | [inline]
nvmath::Vecnf< 3 >::operator-(const Vecnf< n > &v) const | Vecnf< 3 > |
operator-=(const Vecnf< n > &v) | Vecnf< 3 > |
operator/(float f) const | Vecnf< 3 > |
operator/(double f) const | Vecnf< 3 > |
operator/=(float f) | Vecnf< 3 > |
operator/=(double f) | Vecnf< 3 > |
operator=(const Vec4f &v) | Vec3f |
nvmath::Vecnf< 3 >::operator=(const Vecnf< n > &v) | Vecnf< 3 > |
operator==(const Vecnf< n > &v) const | Vecnf< 3 > |
operator[](size_t i) | Vecnf< 3 > |
operator[](size_t i) const | Vecnf< 3 > |
operator^(const Vecnf< 3 > &v0, const Vecnf< 3 > &v1) | Vec3f | [related]
orthogonalize(const Vecnf< n > &v) | Vecnf< 3 > |
orthonormalize(const Vecnf< n > &v) | Vecnf< 3 > |
set(float x, float y, float z) | Vec3f | [inline]
smoothNormals(const std::vector< Vec3f > &vertices, const Sphere3f &sphere, float creaseAngle, std::vector< Vec3f > &normals) | Vec3f | [related]
Vec3f(void) | Vec3f |
Vec3f(float x, float y, float z) | Vec3f |
Vec3f(const Vecnf< 3 > &v) | Vec3f |
Vec3f(const Vecnf< 4 > &v) | Vec3f |
Vecnf(void) | Vecnf< 3 > |
Vecnf(const Vecnf< n > &v) | Vecnf< 3 > |
Generated on Fri Aug 4 08:37:24 2006 for NVSGSDK by NVIDIA


Vec4f Class Reference

Vector class with 4 float components. More...

#include <Vec4f.h>

Inheritance diagram for Vec4f:

[legend]
Collaboration diagram for Vec4f:

[legend]
List of all members.

Public Member Functions

NVSG_API | Vec4f (void)
Default constructor.

NVSG_API | Vec4f (float x, float y, float z, float w)
Constructor using four floats.

NVSG_API | Vec4f (const Vec3f &v3, float w)
Constructor using a Vec3f and a float.

NVSG_API | Vec4f (const Vecnf< 4 > &v)
Copy constructor.

NVSG_API void | set (float x, float y, float z, float w)
Set the Vec4f with four float values.

Related Functions

(Note that these are not member functions.)

const Vec4f | operator * (float f, const Vec4f &v)

Detailed Description

Vector class with 4 float components.

Constructor & Destructor Documentation

Vec4f ( void ) [inline]

Default constructor.

For performance reasons no initialization is performed.

Vec4f | ( | float | x,
 |  | float | y,
 |  | float | z,
 |  | float | w
 | ) | [inline]

Constructor using four floats.

A Vec4f with the given values is constructed.

Vec4f | ( | const Vec3f & | v3,
 |  | float | w
 | ) | [inline]

Constructor using a Vec3f and a float.

Parameters:
v3 | Vec3f with x, y, z component
w | w component

Vec4f ( const Vecnf< 4 > & v ) [inline]

Copy constructor.

Parameters:
v Vec4f to copy

Member Function Documentation

void set | ( | float | x,
 |  | float | y,
 |  | float | z,
 |  | float | w
 | ) | [inline]

Set the Vec4f with four float values.

Friends And Related Function Documentation

const Vec4f operator * | ( | float | f,
 |  | const Vec4f & | v
 | ) | [related]

Multiplication of a scalar with a Vec4f.

Returns:
product of f with v
Parameters:
f | scalar to multiply with
v | Vec4f to multiply

The documentation for this class was generated from the following file:
  • Vec4f.h
Generated on Fri Aug 4 08:37:25 2006 for NVSGSDK by NVIDIA


Member List

Vec4f Member List

This is the complete list of members for Vec4f, including all inherited members.
getPtr(void) const | Vecnf< 4 > |
normalize(void) | Vecnf< 4 > |
operator *(float f, const Vec4f &v) | Vec4f | [related]
nvmath::Vecnf< 4 >::operator *(float f) const | Vecnf< 4 > |
nvmath::Vecnf< 4 >::operator *(double f) const | Vecnf< 4 > |
nvmath::Vecnf< 4 >::operator *(const Vecnf< n > &v) const | Vecnf< 4 > |
operator *=(float f) | Vecnf< 4 > |
operator *=(double f) | Vecnf< 4 > |
operator!=(const Vecnf< n > &v) const | Vecnf< 4 > |
operator+(const Vecnf< n > &v) const | Vecnf< 4 > |
operator+=(const Vecnf< n > &v) | Vecnf< 4 > |
operator-(void) const | Vecnf< 4 > |
operator-(const Vecnf< n > &v) const | Vecnf< 4 > |
operator-=(const Vecnf< n > &v) | Vecnf< 4 > |
operator/(float f) const | Vecnf< 4 > |
operator/(double f) const | Vecnf< 4 > |
operator/=(float f) | Vecnf< 4 > |
operator/=(double f) | Vecnf< 4 > |
operator=(const Vecnf< n > &v) | Vecnf< 4 > |
operator==(const Vecnf< n > &v) const | Vecnf< 4 > |
operator[](size_t i) | Vecnf< 4 > |
operator[](size_t i) const | Vecnf< 4 > |
orthogonalize(const Vecnf< n > &v) | Vecnf< 4 > |
orthonormalize(const Vecnf< n > &v) | Vecnf< 4 > |
set(float x, float y, float z, float w) | Vec4f | [inline]
Vec4f(void) | Vec4f | [inline]
Vec4f(float x, float y, float z, float w) | Vec4f | [inline]
Vec4f(const Vec3f &v3, float w) | Vec4f | [inline]
Vec4f(const Vecnf< 4 > &v) | Vec4f | [inline]
Vecnf(void) | Vecnf< 4 > |
Vecnf(const Vecnf< n > &v) | Vecnf< 4 > |
Generated on Fri Aug 4 08:37:25 2006 for NVSGSDK by NVIDIA


TemplateVecnf class Reference

Vecnf Class Template Reference

Template class for one dimensional vectors of floats. More...

#include <Vecnf.h>

Inheritance diagram for Vecnf:

[legend]
List of all members.

Public Member Functions

Vecnf (void)
Default constructor.

Vecnf (const Vecnf< n > &v)
Copy constructor.

float & | operator[] (size_t i)
Non-constant subscript operator.

const float & | operator[] (size_t i) const
Constant subscript operator.

const Vecnf< n > | operator- (void) const
Negation operator.

const Vecnf< n > | operator * (float f) const
Vecnf multiplication with a scalar operator.

const Vecnf< n > | operator * (double f) const
Vecnf multiplication with a double precision scalar operator.

const float | operator * (const Vecnf< n > &v) const
Vecnf multiplication with a Vecnf (i.e. dot product) operator.

const Vecnf< n > | operator/ (float f) const
Vecnf division by a scalar operator.

const Vecnf< n > | operator/ (double f) const
Vecnf division by a double precision scalar operator.

const Vecnf< n > | operator+ (const Vecnf< n > &v) const
Vecnf addition operator.

const Vecnf< n > | operator- (const Vecnf< n > &v) const
Vecnf subtraction operator.

bool | operator== (const Vecnf< n > &v) const
Vecnf equality operator.

bool | operator!= (const Vecnf< n > &v) const
Vecnf inequality operator.

Vecnf< n > & | operator= (const Vecnf< n > &v)
Vecnf assignment operator.

Vecnf< n > & | operator *= (float f)
Vecnf multiplication with a scalar and assignment operator.

Vecnf< n > & | operator *= (double f)
Vecnf multiplication with a double precision scalar and assignment operator.

Vecnf< n > & | operator/= (float f)
Vecnf division by a scalar and assignment operator.

Vecnf< n > & | operator/= (double f)
Vecnf division by a double precision scalar and assignment operator.

Vecnf< n > & | operator+= (const Vecnf< n > &v)
Vecnf addition and assignment operator.

Vecnf< n > & | operator-= (const Vecnf< n > &v)
Vecnf subtraction and assignment operator.

const float * | getPtr (void) const
Get a constant pointer to the elements of the Vecnf.

float | normalize (void)
Normalize this and return the previous length.

void | orthogonalize (const Vecnf< n > &v)
Orthogonalize this with respect to an other Vecnf.

void | orthonormalize (const Vecnf< n > &v)
Orthonormalize this with respect to an other Vecnf.

Related Functions

(Note that these are not member functions.)

bool | areOpposite (const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON)
bool | areOrthogonal (const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON)
bool | areOrthonormal (const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON)
bool | areSimilar (const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON)
float | distance (const Vecnf< n > &p0, const Vecnf< n > &p1)
bool | isNormalized (const Vecnf< n > &v, float epsilon=FLT_EPSILON)
bool | isNull (const Vecnf< n > &v, float epsilon=FLT_EPSILON)
float | length (const Vecnf< n > &v)
double | lengthd (const Vecnf< n > &v)
float | lengthSquared (const Vecnf< n > &v)
float | maxElement (const Vecnf< n > &v)
float | minElement (const Vecnf< n > &v)
Vecnf< n > | operator * (float f, const Vecnf< n > &v)
Vecnf< n > | operator * (double f, const Vecnf< n > &v)

Detailed Description

template<unsigned char n>
class nvmath::Vecnf< n >

Template class for one dimensional vectors of floats.

Constructor & Destructor Documentation

Vecnf ( void )

Default constructor.

For performance reasons no initialization is performed.

Vecnf ( const Vecnf< n > & v )

Copy constructor.

Parameters:
v Vecnf to copy

Member Function Documentation

float & operator[] ( size_t i )

Non-constant subscript operator.

Returns:
reference to i th element of the Vecnf
Parameters:
i index to use (i=0,..,n-1) in Vecnf

const float & operator[] ( size_t i ) const

Constant subscript operator.

Returns:
constant reference to i th element of the Vecnf
Parameters:
i index to use (i=0,..,n-1) in Vecnf

const Vecnf< n > operator- ( void ) const

Negation operator.

Returns:
negated Vecnf

Reimplemented in Vec3f.

const Vecnf< n > operator * ( float f ) const

Vecnf multiplication with a scalar operator.

Returns:
multiplied Vecnf
Parameters:
f scalar to multiply with

const Vecnf< n > operator * ( double f ) const

Vecnf multiplication with a double precision scalar operator.

Returns:
multiplied Vecnf
Parameters:
f scalar to multiply with

const float operator * ( const Vecnf< n > & v ) const

Vecnf multiplication with a Vecnf (i.e. dot product) operator.

Returns:
dot product of this with v
Parameters:
v Vecnf to multiply with

const Vecnf< n > operator/ ( float f ) const

Vecnf division by a scalar operator.

Returns:
divided Vecnf
Parameters:
f scalar to divide through

const Vecnf< n > operator/ ( double f ) const

Vecnf division by a double precision scalar operator.

Returns:
divided Vecnf
Parameters:
f scalar to divide through

const Vecnf< n > operator+ ( const Vecnf< n > & v ) const

Vecnf addition operator.

Returns:
sum of the this and v
Parameters:
v Vecnf to add

const Vecnf< n > operator- ( const Vecnf< n > & v ) const

Vecnf subtraction operator.

Returns:
difference of the two vectors
Parameters:
v Vecnf to subtract

bool operator== ( const Vecnf< n > & v ) const

Vecnf equality operator.

Two Vecnf are considered to be equal, if they differ less epsilon in each component.

Returns:
true if this is equal to v, otherwise false
Parameters:
v Vecnf to compare with

bool operator!= ( const Vecnf< n > & v ) const

Vecnf inequality operator.

Two Vecnf are considered to be equal, if they differ less epsilon in each component.

Returns:
true if this is not equal to v, otherwise false
Parameters:
v Vecnf to compare with

Vecnf< n > & operator= ( const Vecnf< n > & v )

Vecnf assignment operator.

Returns:
reference to the assigned Vecnf
Parameters:
v Vecnf to copy

Vecnf< n > & operator *= ( float f )

Vecnf multiplication with a scalar and assignment operator.

Returns:
reference to the assigned Vecnf after multiplication
Parameters:
f scalar to multiply with

Vecnf< n > & operator *= ( double f )

Vecnf multiplication with a double precision scalar and assignment operator.

Returns:
reference to the assigned Vecnf after multiplication
Parameters:
f scalar to multiply with

Vecnf< n > & operator/= ( float f )

Vecnf division by a scalar and assignment operator.

Returns:
reference to the assigned Vecnf after division
Parameters:
f scalar to divide by

Vecnf< n > & operator/= ( double f )

Vecnf division by a double precision scalar and assignment operator.

Returns:
reference to the assigned Vecnf after division
Parameters:
f scalar to divide by

Vecnf< n > & operator+= ( const Vecnf< n > & v )

Vecnf addition and assignment operator.

Returns:
reference to the assigned Vecnf after addition
Parameters:
v Vecnf to add

Vecnf< n > & operator-= ( const Vecnf< n > & v )

Vecnf subtraction and assignment operator.

Returns:
reference to the assigned Vecnf after subtraction
Parameters:
v Vecnf to subtract

const float * getPtr ( void ) const

Get a constant pointer to the elements of the Vecnf.

Returns:
constant pointer to elements of this

float normalize ( void )

Normalize this and return the previous length.

Returns:
length of this before normalization

void orthogonalize ( const Vecnf< n > & v )

Orthogonalize this with respect to an other Vecnf.

Sets this to be orthogonal to v.

Parameters:
v Vecnf to orthogonalize to

void orthonormalize ( const Vecnf< n > & v )

Orthonormalize this with respect to an other Vecnf.

Sets this to be orthonormal to the normalized Vecnf v.

Parameters:
v Vecnf to orthonormalize to

Friends And Related Function Documentation

bool areOpposite | ( | const Vecnf< n > & | v0,
 |  | const Vecnf< n > & | v1,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if two Vecnf are opposite to each other.
Two normalized Vecnf are considered to be opposite, if their dot product deviates less than epsilon from -1.

Returns:
true if the Vecnf are opposite, otherwise false

bool areOrthogonal | ( | const Vecnf< n > & | v0,
 |  | const Vecnf< n > & | v1,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if two Vecnf are orthogonal to each other.
Two Vecnf are considered to be orthogonal, if their dot product deviates less than epsilon from zero.

Returns:
true if the Vecnf are orthogonal, otherwise false
Parameters:
epsilon optional epsilon

bool areOrthonormal | ( | const Vecnf< n > & | v0,
 |  | const Vecnf< n > & | v1,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if two Vecnf are orthonormal to each other.
Two Vecnf are orthonormal, if they are both normalized and orthogonal to each other.

Returns:
true if the Vecnf are orthonormal, otherwise false
Parameters:
epsilon optional epsilon

bool areSimilar | ( | const Vecnf< n > & | v0,
 |  | const Vecnf< n > & | v1,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if two Vecnf are similar to each other.
Two Vecnf are considered to be similar, if they differ less than a given tolerance in each component.
Without providing the optional parameter tol, areSimilar() gives the same result as operator==().

Returns:
true if the Vecnf are similar, otherwise false
Parameters:
epsilon optional epsilon

float distance | ( | const Vecnf< n > & | p0,
 |  | const Vecnf< n > & | p1
 | ) | [related]

Determine the distance between two Vecnf. If p0 and p1 are interpreted as two points in n-space, the distance is the euclidean distance in that space.

Returns:
The distance between p0 and p1

bool isNormalized | ( | const Vecnf< n > & | v,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Vecnf is normalized.
A Vecnf is considered to be normalized if its length differs less than epsilon from one.

Returns:
true if the Vecnf is normalized, otherwise false
Parameters:
v | Vecnf to test
epsilon | optional epsilon

bool isNull | ( | const Vecnf< n > & | v,
 |  | float | epsilon = FLT_EPSILON
 | ) | [related]

Test if a Vecnf is a null Vecnf.
A Vecnf is considered to be a null Vecnf if its length differs less than epsilon form zero.

Returns:
true if the Vecnf is a null Vecnf, otherwise false
Parameters:
v | Vecnf to test
epsilon | optional epsilon

float length ( const Vecnf< n > & v ) [related]

Calculate the length of a Vecnf. If v is interpreted as a vector in n-space, the length is the euclidean length in that space.

Returns:
length of v
Parameters:
v Vecnf to get length of

double lengthd ( const Vecnf< n > & v ) [related]

Calculate the length of a Vecnf with double precision. If v is interpreted as a vector in n-space, the length is the euclidean length in that space.

Returns:
length of v
Parameters:
v Vecnf to get length of

float lengthSquared ( const Vecnf< n > & v ) [related]

Calculate the squared length of a Vecnf.

Returns:
squared length of v
Parameters:
v Vecnf to get squared length of

float maxElement ( const Vecnf< n > & v ) [related]

Get the maximal absolute value of a \ Vecnf.

Returns:
maximal element of v
Parameters:
v Vecnf to get maximal element of

float minElement ( const Vecnf< n > & v ) [related]

Get the minimal absolute value of a Vecnf.

Returns:
minimal element of v
Parameters:
v Vecnf to get minimal element of

Vecnf< n > operator * | ( | float | f,
 |  | const Vecnf< n > & | v
 | ) | [related]

Multiplication of a scalar with a Vecnf.

Returns:
product of f with v
Parameters:
f | scalar to multiply with
v | Vecnf to multiply

Vecnf< n > operator * | ( | double | f,
 |  | const Vecnf< n > & | v
 | ) | [related]

Multiplication of a double precision scalar with a Vecnf.

Returns:
product of f with v
Parameters:
f | scalar to multiply with
v | Vecnf to multiply

The documentation for this class was generated from the following file:
  • Vecnf.h
Generated on Fri Aug 4 08:37:26 2006 for NVSGSDK by NVIDIA


Member List

Vecnf Member List

This is the complete list of members for Vecnf, including all inherited members.
areOpposite(const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON) | Vecnf | [related]
areOrthogonal(const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON) | Vecnf | [related]
areOrthonormal(const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON) | Vecnf | [related]
areSimilar(const Vecnf< n > &v0, const Vecnf< n > &v1, float epsilon=FLT_EPSILON) | Vecnf | [related]
distance(const Vecnf< n > &p0, const Vecnf< n > &p1) | Vecnf | [related]
getPtr(void) const | Vecnf |
isNormalized(const Vecnf< n > &v, float epsilon=FLT_EPSILON) | Vecnf | [related]
isNull(const Vecnf< n > &v, float epsilon=FLT_EPSILON) | Vecnf | [related]
length(const Vecnf< n > &v) | Vecnf | [related]
lengthd(const Vecnf< n > &v) | Vecnf | [related]
lengthSquared(const Vecnf< n > &v) | Vecnf | [related]
maxElement(const Vecnf< n > &v) | Vecnf | [related]
minElement(const Vecnf< n > &v) | Vecnf | [related]
normalize(void) | Vecnf |
operator *(float f) const | Vecnf |
operator *(double f) const | Vecnf |
operator *(const Vecnf< n > &v) const | Vecnf |
operator *(float f, const Vecnf< n > &v) | Vecnf | [related]
operator *(double f, const Vecnf< n > &v) | Vecnf | [related]
operator *=(float f) | Vecnf |
operator *=(double f) | Vecnf |
operator!=(const Vecnf< n > &v) const | Vecnf |
operator+(const Vecnf< n > &v) const | Vecnf |
operator+=(const Vecnf< n > &v) | Vecnf |
operator-(void) const | Vecnf |
operator-(const Vecnf< n > &v) const | Vecnf |
operator-=(const Vecnf< n > &v) | Vecnf |
operator/(float f) const | Vecnf |
operator/(double f) const | Vecnf |
operator/=(float f) | Vecnf |
operator/=(double f) | Vecnf |
operator=(const Vecnf< n > &v) | Vecnf |
operator==(const Vecnf< n > &v) const | Vecnf |
operator[](size_t i) | Vecnf |
operator[](size_t i) const | Vecnf |
orthogonalize(const Vecnf< n > &v) | Vecnf |
orthonormalize(const Vecnf< n > &v) | Vecnf |
Vecnf(void) | Vecnf |
Vecnf(const Vecnf< n > &v) | Vecnf |
Generated on Fri Aug 4 08:37:26 2006 for NVSGSDK by NVIDIA


VertexAttributeSet Class Reference

Class to hold one set of vertex attributes. More...

#include <VertexAttributeSet.h>

Inheritance diagram for VertexAttributeSet:

[legend]
Collaboration diagram for VertexAttributeSet:

[legend]
List of all members.

Public Types

enum {
VERTEX_POSITION = 0, VERTEX_WEIGHTS, NORMAL, PRIMARY_COLOR,
SECONDARY_COLOR, FOG_COORDINATE, UNUSED_1, UNUSED_2,
TEXTURE_COORD_0, TEXTURE_COORD_1, TEXTURE_COORD_2, TEXTURE_COORD_3,
TEXTURE_COORD_4, TEXTURE_COORD_5, TEXTURE_COORD_6, TEXTURE_COORD_7,
NUMBER_OF_VERTEX_ATTRIBUTES
}
Vertex Attribute Register Numbers. More...

enum {
V3F = BIT0, VW1F = BIT1, N3F = BIT2, VC3F = BIT3,
VC4F = BIT4, SVC3F = BIT5, SVC4F = BIT6, F1F = BIT7,
T01F = BIT8, T02F = BIT9, T03F = BIT10, T11F = BIT11,
T12F = BIT12, T13F = BIT13, T21F = BIT14, T22F = BIT15,
T23F = BIT16, T31F = BIT17, T32F = BIT18, T33F = BIT19,
T41F = BIT20, T42F = BIT21, T43F = BIT22, T51F = BIT23,
T52F = BIT24, T53F = BIT25, T61F = BIT26, T62F = BIT27,
T63F = BIT28, T71F = BIT29, T72F = BIT30, T73F = BIT31,
V3F_N3F = V3F | N3F, V3F_N3F_VC3F = V3F | N3F | VC3F, V3F_N3F_VC4F = V3F | N3F | VC4F, V3F_N3F_VC3F_T2F = V3F | N3F | VC3F | T02F,
V3F_N3F_VC4F_T2F = V3F | N3F | VC4F | T02F, V3F_N3F_T2F = V3F | N3F | T02F, V3F_N3F_T2F_TG3F_BN3F = V3F | N3F | T02F | T13F | T23F
}
Format bits to reflect the interleaved format. More...

Public Member Functions

virtual NVSG_API const VertexAttributeSet * | clone (void) const
Get a clone of this VertexAttributeSet object.

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 unsigned int | getInterleavedFormat () const
Returns the interleave format.

NVSG_API size_t | getNumberOfVertexAttributeBytes (size_t attrib) const
Get amount of data bytes currently stored in the vertex attribute specified by attrib.

NVSG_API const float * | getVertexAttributeData (size_t attrib) const
Get float data stored in the vertex attribute specified by attrib.

NVSG_API unsigned int | getVertexAttributeDataDim (size_t attrib) const
Determine the dimension, in terms of float, of the data stored in the vertex attribute specified by attrib.

NVSG_API size_t | getNumberOfVertexAttributeData (size_t attrib) const
Determine if data is available for a vertex attribute specified by attrib.

NVSG_API void | setVertexAttributeData (size_t attrib, unsigned int fdim, const float *fdata, size_t count)
Set data for the vertex attribute specified by attrib.

NVSG_API void | setVertexAttributeData (size_t attrib, unsigned int fdim, size_t pos, const float *fdata, size_t count)
Set data for the vertex attribute specified by attrib.

NVSG_API void | clearVertexAttributeData (size_t attrib)
Remove any data for the specified attrib.

NVSG_API size_t | getNumberOfVertices (void) const
Get number of vertices.

NVSG_API const nvmath::Vec3f * | getVertices (void) const
Get vertices.

NVSG_API void | setVertices (const nvmath::Vec3f *verts, size_t count)
Set vertices for this VertexAttributeSet.

NVSG_API void | setVertices (size_t pos, const nvmath::Vec3f *verts, size_t count)
Set vertices for this VertexAttributeSet.

NVSG_API size_t | getNumberOfNormals (void) const
Get number of normals.

NVSG_API const nvmath::Vec3f * | getNormals (void) const
Get normals.

NVSG_API void | setNormals (const nvmath::Vec3f *nor, size_t count)
Set normals for this VertexAttributeSet.

NVSG_API void | setNormals (size_t pos, const nvmath::Vec3f *nor, size_t count)
Set normals for this VertexAttributeSet.

NVSG_API bool | hasTexCoords (void) const
Determine if at least one texture coordinate array has valid texture coordinates.

NVSG_API size_t | getNumberOfTexCoords (size_t texUnit) const
Get number of texture coordinates in a specified texture unit.

NVSG_API const float * | getTexCoords (size_t texUnit) const
Get texture coordinates for a specified texture unit.

NVSG_API unsigned int | getTexCoordsDim (size_t texUnit) const
Get the dimension of the texture coordinates stored in the specified texture unit.

NVSG_API void | clearTexCoords (size_t texUnit)
Clear the texture coordinates for a specified texture unit.

NVSG_API void | setTexCoords (size_t texUnit, unsigned int fdim, const float *coords, size_t count)
Set the texture coordinates for a specified texture unit.

NVSG_API void | setTexCoords (size_t texUnit, unsigned int fdim, size_t pos, const float *coords, size_t count)
Set the texture coordinates for a specified texture unit.

NVSG_API size_t | getNumberOfColors (void) const
Get number of colors.

NVSG_API const float * | getColors (void) const
Get constant pointer to colors.

NVSG_API unsigned int | getColorsDim (void) const
Get the dimension of the colors.

NVSG_API void | setColors (unsigned int fdim, const float *cols, size_t count)
Set colors for this VertexAttributeSet.

NVSG_API void | setColors (unsigned int fdim, size_t pos, const float *cols, size_t count)
Set colors for this VertexAttributeSet.

NVSG_API size_t | getNumberOfSecondaryColors (void) const
Get number of secondary colors.

NVSG_API const float * | getSecondaryColors (void) const
Get constant pointer to secondary colors.

NVSG_API unsigned int | getSecondaryColorsDim (void) const
Get the dimension of the secondary colors.

NVSG_API void | setSecondaryColors (unsigned int fdim, const float *cols, size_t count)
Set secondary colors for this VertexAttributeSet.

NVSG_API void | setSecondaryColors (unsigned int fdim, size_t pos, const float *cols, size_t count)
Set secondary colors for this VertexAttributeSet.

NVSG_API size_t | getNumberOfFogCoords (void) const
Get number of fog coordinates.

NVSG_API const float * | getFogCoords (void) const
Get fog coordinates.

NVSG_API void | setFogCoords (const float *coords, size_t count)
Set the fog coordinates.

NVSG_API void | setFogCoords (size_t pos, const float *coords, size_t count)
Set the fog coordinates.

NVSG_API size_t | getNumberOfOwners (void) const
Get the number of owners of this VertexAttributeSet.

NVSG_API const PrimitiveSet * | getOwner (size_t index) const
Get a constant pointer to the owner at position index.

NVSG_API VertexAttributeSet & | operator= (const VertexAttributeSet &rhs)
Assignement operator.

virtual NVSG_API bool | isEquivalent (const Object *p, bool ignoreNames, bool deepCompare) const
Test for equivalence with an other VertexAttributeSet.

Static Public Member Functions

NVSG_API const VertexAttributeSet * | create (void)
Create a VertexAttributeSet.

Protected Member Functions

NVSG_API | VertexAttributeSet (void)
Constructor.

NVSG_API | VertexAttributeSet (const VertexAttributeSet &rhs)
Copy Constructor.

virtual NVSG_API | ~VertexAttributeSet (void)
Protected destructor to prevent explicit creation on stack.

virtual NVSG_API void | invalidateIncarnation (void)
Invalidate the Incarnation.

Related Functions

(Note that these are not member functions.)

NVSG_API void | generateTexCoords (VertexAttributeSet *vas, TextureCoordType tct, const nvmath::Sphere3f &sphere, size_t tu=0)

Detailed Description

Class to hold one set of vertex attributes.

This class only holds the vertex and attribute data. Any information about how they are connected has to be provided by topology specific classes (such as VertexAttributeSet, etc ...).

Member Enumeration Documentation

anonymous enum

Vertex Attribute Register Numbers.

These represent valid indices identifying a certain vertex attribute.

anonymous enum

Format bits to reflect the interleaved format.

Constructor & Destructor Documentation

NVSG_API VertexAttributeSet ( void ) [protected]

Constructor.

NVSG_API VertexAttributeSet ( const VertexAttributeSet & rhs ) [protected]

Copy Constructor.

virtual NVSG_API ~VertexAttributeSet ( void ) [protected, virtual]

Protected destructor to prevent explicit creation on stack.

Member Function Documentation

NVSG_API const VertexAttributeSet* create ( void ) [static]

Create a VertexAttributeSet.

Returns:
a constant pointer to a VertexAttributeSet.

virtual NVSG_API const VertexAttributeSet* clone ( void ) const [virtual]

Get a clone of this VertexAttributeSet object.

Returns:
A constant pointer to a VertexAttributeSet.

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.

unsigned int getInterleavedFormat ( ) const [inline]

Returns the interleave format.

Returns:
Format bits - see V3F, VW1F, N3F, etc

NVSG_API size_t getNumberOfVertexAttributeBytes ( size_t attrib ) const

Get amount of data bytes currently stored in the vertex attribute specified by attrib.

Returns:
The number of bytes used.
Note:
The behavior is undefined when passing an invalid index for attrib. Valid indices are:
VertexAttributeSet::VERTEX_POSITION
VertexAttributeSet::VERTEX_WEIGHTS
VertexAttributeSet::NORMAL
VertexAttributeSet::PRIMARY_COLOR
VertexAttributeSet::SECONDARY_COLOR
VertexAttributeSet::FOG_COORDINATE
VertexAttributeSet::UNUSED_1
VertexAttributeSet::UNUSED_2
VertexAttributeSet::TEXTURE_COORD_0
VertexAttributeSet::TEXTURE_COORD_1
VertexAttributeSet::TEXTURE_COORD_2
VertexAttributeSet::TEXTURE_COORD_3
VertexAttributeSet::TEXTURE_COORD_4
VertexAttributeSet::TEXTURE_COORD_5
VertexAttributeSet::TEXTURE_COORD_6
VertexAttributeSet::TEXTURE_COORD_7
The indices listed here are a contiguous set of indices and range from 0 to 15.
Parameters:
attrib Zero based index identifying the target vertex attribute.

const float * getVertexAttributeData ( size_t attrib ) const [inline]

Get float data stored in the vertex attribute specified by attrib.

Returns:
A valid pointer to the vertex attribute's data if data was stored in the vertex attribute, a NULL pointer otherwise.
Note:
The behavior is undefined when passing an invalid index for attrib. Valid indices are:
VertexAttributeSet::VERTEX_POSITION
VertexAttributeSet::VERTEX_WEIGHTS
VertexAttributeSet::NORMAL
VertexAttributeSet::PRIMARY_COLOR
VertexAttributeSet::SECONDARY_COLOR
VertexAttributeSet::FOG_COORDINATE
VertexAttributeSet::UNUSED_1
VertexAttributeSet::UNUSED_2
VertexAttributeSet::TEXTURE_COORD_0
VertexAttributeSet::TEXTURE_COORD_1
VertexAttributeSet::TEXTURE_COORD_2
VertexAttributeSet::TEXTURE_COORD_3
VertexAttributeSet::TEXTURE_COORD_4
VertexAttributeSet::TEXTURE_COORD_5
VertexAttributeSet::TEXTURE_COORD_6
VertexAttributeSet::TEXTURE_COORD_7
The indices listed here are a contiguous set of indices and range from 0 to 15.
Parameters:
attrib Zero based index identifying the target vertex attribute.

unsigned int getVertexAttributeDataDim ( size_t attrib ) const [inline]

Determine the dimension, in terms of float, of the data stored in the vertex attribute specified by attrib.

The native data format for data stored in a vertex attribute is float, thus the reason for expressing a data element's dimension in terms of float. A single vertex position, for example, is of dimension 3, which is one single-precision float value for representing a direction in a 3-dimensional space.

Returns:
The dimension, in terms of float, of the data elements stored in the specified vertex attribute. If there is no data currently stored in that vertex attribute, the function returns 0.
Note:
The behavior is undefined when passing an invalid index for attrib. Valid indices are:
VertexAttributeSet::VERTEX_POSITION
VertexAttributeSet::VERTEX_WEIGHTS
VertexAttributeSet::NORMAL
VertexAttributeSet::PRIMARY_COLOR
VertexAttributeSet::SECONDARY_COLOR
VertexAttributeSet::FOG_COORDINATE
VertexAttributeSet::UNUSED_1
VertexAttributeSet::UNUSED_2
VertexAttributeSet::TEXTURE_COORD_0
VertexAttributeSet::TEXTURE_COORD_1
VertexAttributeSet::TEXTURE_COORD_2
VertexAttributeSet::TEXTURE_COORD_3
VertexAttributeSet::TEXTURE_COORD_4
VertexAttributeSet::TEXTURE_COORD_5
VertexAttributeSet::TEXTURE_COORD_6
VertexAttributeSet::TEXTURE_COORD_7
The indices listed here are a contiguous set of indices and range from 0 to 15.
Parameters:
attrib Identifies the target vertex attribute.

size_t getNumberOfVertexAttributeData ( size_t attrib ) const [inline]

Determine if data is available for a vertex attribute specified by attrib.

Returns:
The number of stored data elements.
Note:
The behavior is undefined when passing an invalid index for attrib. Valid indices are:
VertexAttributeSet::VERTEX_POSITION
VertexAttributeSet::VERTEX_WEIGHTS
VertexAttributeSet::NORMAL
VertexAttributeSet::PRIMARY_COLOR
VertexAttributeSet::SECONDARY_COLOR
VertexAttributeSet::FOG_COORDINATE
VertexAttributeSet::UNUSED_1
VertexAttributeSet::UNUSED_2
VertexAttributeSet::TEXTURE_COORD_0
VertexAttributeSet::TEXTURE_COORD_1
VertexAttributeSet::TEXTURE_COORD_2
VertexAttributeSet::TEXTURE_COORD_3
VertexAttributeSet::TEXTURE_COORD_4
VertexAttributeSet::TEXTURE_COORD_5
VertexAttributeSet::TEXTURE_COORD_6
VertexAttributeSet::TEXTURE_COORD_7
The indices listed here are a contiguous set of indices and range from 0 to 15.
Parameters:
attrib Identifies the target vertex attribute.

NVSG_API void setVertexAttributeData | ( | size_t | attrib,
 |  | unsigned int | fdim,
 |  | const float * | fdata,
 |  | size_t | count
 | ) |

Set data for the vertex attribute specified by attrib.

The function copies fdim * count float values from the location pointed to by fdata to the vertex attribute specified by attrib. Pre-existing data of the specified vertex attribute will be entirely erased.

Note:
The behavior is undefined when passing an invalid index for attrib. Valid indices are:
VertexAttributeSet::VERTEX_POSITION
VertexAttributeSet::VERTEX_WEIGHTS
VertexAttributeSet::NORMAL
VertexAttributeSet::PRIMARY_COLOR
VertexAttributeSet::SECONDARY_COLOR
VertexAttributeSet::FOG_COORDINATE
VertexAttributeSet::UNUSED_1
VertexAttributeSet::UNUSED_2
VertexAttributeSet::TEXTURE_COORD_0
VertexAttributeSet::TEXTURE_COORD_1
VertexAttributeSet::TEXTURE_COORD_2
VertexAttributeSet::TEXTURE_COORD_3
VertexAttributeSet::TEXTURE_COORD_4
VertexAttributeSet::TEXTURE_COORD_5
VertexAttributeSet::TEXTURE_COORD_6
VertexAttributeSet::TEXTURE_COORD_7
The indices listed here are a contiguous set of indices and range from 0 to 15.
The behavior is also undefined if either fdim doesn't match the correct dimension, in terms of float, of the data pointed to by fdata, or if fdata is an invalid pointer, or if count exceeds the actual number of source data elements.
Parameters:
attrib | Identifies the target vertex attribute.
fdim | Dimension, in terms of float, of the source data elements.
fdata | Address of source data.
count | Number of source data elements.

NVSG_API void setVertexAttributeData | ( | size_t | attrib,
 |  | unsigned int | fdim,
 |  | size_t | pos,
 |  | const float * | fdata,
 |  | size_t | count
 | ) |

Set data for the vertex attribute specified by attrib.

The function copies fdim * count float values from the location pointed to by fdata to the vertex attribute specified by attrib, starting at position pos of the pre-existing vertex data. Pre-existing vertex data in the range [pos, pos + count) will be replaced. Pre-existing data outside this range remains untouched.

If you specify -1 for pos or if pos specifies the number of elements currently stored for the vertex attribute specified by attrib, the data pointed to by fdata will be appended to the pre-existing vertex data.

If you not specify -1 for pos or pos neither specifies the number of elements currently stored for the specified vertex attribute nor does it specify a valid position inside the range of pre-existing data, the behaviour is undefined!

Note:
The behavior is undefined when passing an invalid index for attrib. Valid indices are:
VertexAttributeSet::VERTEX_POSITION
VertexAttributeSet::VERTEX_WEIGHTS
VertexAttributeSet::NORMAL
VertexAttributeSet::PRIMARY_COLOR
VertexAttributeSet::SECONDARY_COLOR
VertexAttributeSet::FOG_COORDINATE
VertexAttributeSet::UNUSED_1
VertexAttributeSet::UNUSED_2
VertexAttributeSet::TEXTURE_COORD_0
VertexAttributeSet::TEXTURE_COORD_1
VertexAttributeSet::TEXTURE_COORD_2
VertexAttributeSet::TEXTURE_COORD_3
VertexAttributeSet::TEXTURE_COORD_4
VertexAttributeSet::TEXTURE_COORD_5
VertexAttributeSet::TEXTURE_COORD_6
VertexAttributeSet::TEXTURE_COORD_7
The indices listed here are a contiguous set of indices and range from 0 to 15.
The behavior is also undefined if either fdim doesn't match the correct dimension, in terms of float, of the data element currently stored for the specified vertex attribute, or if fdata is an invalid pointer.
Parameters:
attrib | Identifies the target vertex attribute.
fdim | Dimension, in terms of float, of the source data element.
pos | Position in contigious memory of the vertex attribute's data set.
fdata | Address of source data.
count | Number of source data elements.

NVSG_API void clearVertexAttributeData ( size_t attrib )

Remove any data for the specified attrib.

Parameters:
attrib Identifies the target vertex attribute

size_t getNumberOfVertices ( void ) const [inline]

Get number of vertices.

Returns:
The number of vertices.
Note:
Calling this function has the same effect as calling getNumberOfVertexAttributeData(VERTEX_POSITION).

const nvmath::Vec3f * getVertices ( void ) const [inline]

Get vertices.

Returns:
A pointer to the vertices.
Note:
Calling this function has the same effect as calling getVertexAttributeData(VERTEX_POSITION). The only difference is, that this function returns a const Vec3f* rather than a const float* to reflect a vertex position's dimension. One must keep this in mind when it comes to pointer arithmetics!

void setVertices | ( | const nvmath::Vec3f * | verts,
 |  | size_t | count
 | ) | [inline]

Set vertices for this VertexAttributeSet.

Copies count vertices from the location pointed to by verts into this VertexAttributeSet. Pre-existing vertices will be entirely erased.

Note:
The behaviour is undefined if either verts is invalid, or if count exceeds the actual number of vertices stored at verts.
Parameters:
verts | vertices to set
count | number of vertices

void setVertices | ( | size_t | pos,
 |  | const nvmath::Vec3f * | verts,
 |  | size_t | count
 | ) | [inline]

Set vertices for this VertexAttributeSet.

Copies count vertices from the location pointed to by verts into this VertexAttributeSet, starting at position pos inside the range of pre-existing vertices. Pre-existing vertices in the range [pos, pos + count) will be replaced. Pre-existing vertices outside this range remain untouched.

If you specify -1 for pos or if pos specifies the number of vertices currently stored the vertices pointed to by verts will be appended to the pre-existing vertices.

If you not specify -1 for pos or pos neither specifies the number of vertices currently stored nor does it specify a valid position inside the range of pre-existing vertices, the behaviour is undefined!

Note:
The behaviour is undefined if either verts is invalid, or if count exceeds the actual number of vertices stored at verts.
Parameters:
pos | Start position inside the range of pre-existing vertices.
verts | Start address of vertices to set.
count | Number of vertices to copy.

size_t getNumberOfNormals ( void ) const [inline]

Get number of normals.

Returns:
The number of normals.
Note:
Calling this function has the same effect as calling getNumberOfVertexAttributeData(NORMAL).

const nvmath::Vec3f * getNormals ( void ) const [inline]

Get normals.

Returns:
A pointer to the normals.
Note:
Calling this function has the same effect as calling getVertexAttributeData(NORMAL). The only difference is, that this function returns a const Vec3f* rather than a const float* to reflect a normal's dimension. One must keep this in mind when it comes to pointer arithmetics!

void setNormals | ( | const nvmath::Vec3f * | nor,
 |  | size_t | count
 | ) | [inline]

Set normals for this VertexAttributeSet.

Copies count normals from the location pointed to by nor into this VertexAttributeSet. Pre-existing normals will be entirely erased.

Note:
The behaviour is undefined if either nor is invalid, or if count exceeds the actual number of normals stored at nor.
Parameters:
nor | Address of source normals.
count | Number of normals to set.

void setNormals | ( | size_t | pos,
 |  | const nvmath::Vec3f * | nor,
 |  | size_t | count
 | ) | [inline]

Set normals for this VertexAttributeSet.

Copies count normals from the location pointed to by nor into this VertexAttributeSet, starting at position pos inside the range of pre-existing normals. Pre-existing normals in the range [pos, pos + count) will be replaced. Pre-existing normals outside this range remain untouched. If you specify -1 for pos or if pos specifies the number of normals currently stored, the normals pointed to by nor will be appended to the pre-existing normals. If you not specify -1 for pos or pos neither specifies the number of normals currently stored nor does it specify a valid position inside the range of pre-existing normals, the behaviour is undefined!

Note:
The behaviour is undefined if either nor is invalid, or if count exceeds the actual number of normals stored at nor.
Parameters:
pos | Start position inside the range of pre-existing normals.
nor | Start address of normals to set.
count | Number of normals to copy.

bool hasTexCoords ( void ) const [inline]

Determine if at least one texture coordinate array has valid texture coordinates.

Returns:
true, if this VertexAttributeSet has texture coordinates, false otherwise.

size_t getNumberOfTexCoords ( size_t texUnit ) const [inline]

Get number of texture coordinates in a specified texture unit.

Returns:
The number of texture coordinates in texture unit texUnit.
Note:
Calling the function has the same effect as calling getNumberOfVertexAttributeData(TEXTURE_COORD_0 + texUnit).

The behavior is undefined if texUnit specifies an invalid index. A valid index ranges from 0 to 7.

Parameters:
texUnit The zero based index of the texture unit.

const float * getTexCoords ( size_t texUnit ) const [inline]

Get texture coordinates for a specified texture unit.

Returns:
A pointer to the texture coords.
Note:
Texture coordinates can be either 1, 2, 3, or 4-dimensional in terms of float. Call either getTexCoordDim(texUnit) or getVertexAttributeDataDim(TEXTURE_COORD_0 + texUnit) to determine the dimension of the texture coordinates stored in texture unit texUnit.

The behavior is undefined if texUnit specifies an invalid index. A valid index ranges from 0 to 7.

Parameters:
texUnit The zero based index of the texture unit.

unsigned int getTexCoordsDim ( size_t texUnit ) const [inline]

Get the dimension of the texture coordinates stored in the specified texture unit.

The dimension of texture coordinates is meant in terms of floats. Texture coordinates can be either 1, 2, 3, or 4-dimensional.

Returns:
The dimension of the texture coordinates stored in texture unit texUnit. If there are no texture coordinates stored in that texture unit, the function returns 0.
Note:
The behavior is undefined if texUnit specifies an invalid index. A valid index ranges from 0 to 7.
Parameters:
texUnit The zero based index of the texture unit.

void clearTexCoords ( size_t texUnit ) [inline]

Clear the texture coordinates for a specified texture unit.

Parameters:
texUnit The zero based index of the texture unit.

void setTexCoords | ( | size_t | texUnit,
 |  | unsigned int | fdim,
 |  | const float * | coords,
 |  | size_t | count
 | ) | [inline]

Set the texture coordinates for a specified texture unit.

Copies count texture coordinates of dimension dim from the location pointed to by coords into the texture unit texUnit of this VertexAttributeSet.
Valid values for fdim are either 1, 2, 3, or 4. A valid index for texUnit ranges from 0 to 7.

Note:
The behavior is undefined if either texUnit specifies an invalid index, or fdim doesn't match the correct dimension, in terms of float, of the data pointed to by coords, or coords is an invalid pointer, or count exceeds the actual number of source coordinates.
Parameters:
texUnit | The zero based index of the texture unit.
fdim | Dimension of coordinates, in terms of float
coords | Address of source coordinates
count | Number of coordinates to copy

void setTexCoords | ( | size_t | texUnit,
 |  | unsigned int | fdim,
 |  | size_t | pos,
 |  | const float * | coords,
 |  | size_t | count
 | ) | [inline]

Set the texture coordinates for a specified texture unit.

Copies count texture coordinates of dimension dim from the location pointed to by coords into the texture unit texUnit of this VertexAttributeSet, starting at position pos inside the range of pre-existing texture coordinates. Valid values for fdim are either 1, 2, 3, or 4. A valid index for texUnit ranges from 0 to 7. Pre-existing coordinates in the range [pos, pos + count) will be replaced. Pre-existing coordinates outside this range remain untouched. If you specify -1 for pos or if pos specifies the number of coordinates currently stored the coordinates pointed to by coords will be appended to the pre-existing coordinates. If you not specify -1 for pos or pos neither specifies the number of coordinates currently stored nor does it specify a valid position inside the range of pre-existing coordinates, the behaviour is undefined!

Note:
The behavior is undefined if either texUnit specifies an invalid index, or fdim doesn't match the correct dimension, in terms of float, of the data pointed to by coords, or coords is an invalid pointer, or count exceeds the actual number of source coordinates.
Parameters:
texUnit | The zero based index of the texture unit.
fdim | Dimension of coordinates, in terms of float
pos | Start position inside the range of pre-existing texture coordinates.
coords | Address of source coordinates
count | Number of coordinates to copy

size_t getNumberOfColors ( void ) const [inline]

Get number of colors.

Returns:
The number of colors.

const float * getColors ( void ) const [inline]

Get constant pointer to colors.

Note:
It is a mistake to call getColors on a VertexAttributeSet that has no colors available. For this reason, the client code should either call hasColors or getNumberOfColors on that VertexAttributeSet to ensure that colors are available for that VertexAttributeSet.
Returns:
A constant pointer to The colors.

unsigned int getColorsDim ( void ) const [inline]

Get the dimension of the colors.

The dimension of colors is conveyed in terms of floats. With this in mind, colors can be either 3-dimensional - occupying 3 floating point values per color, or 4-dimensional - occupying 4 floating point values per color.

Returns:
The dimension of the colors stored. If there are no colors stored, the function return 0.

void setColors | ( | unsigned int | fdim,
 |  | const float * | cols,
 |  | size_t | count
 | ) | [inline]

Set colors for this VertexAttributeSet.

Copies count colors of dimension fdim from the location pointed to by cols to this VertexAttributeSet.
Valid values for fdim are 3 and 4.

Note:
The behavior is undefined if either fdim doesn't match the correct dimension, in terms of float, of the colors pointed to by cols, or cols is an invalid pointer, or count exceeds the actual number of source colors.
Parameters:
fdim | Dimension of colors, in terms of float
cols | Address of source colors
count | Number of colors to copy

void setColors | ( | unsigned int | fdim,
 |  | size_t | pos,
 |  | const float * | cols,
 |  | size_t | count
 | ) | [inline]

Set colors for this VertexAttributeSet.

Copies count colors of dimension fdim from the location pointed to by cols to this VertexAttributeSet, starting at position pos inside the range of pre-existing colors. Valid values for fdim are 3 and 4. Pre-existing colors in the range [pos, pos + count) will be replaced. Pre-existing colors outside this range remain untouched. If you specify -1 for pos or if pos specifies the number of colors currently stored the colors pointed to by cols will be appended to the pre-existing colors. If you not specify -1 for pos or pos neither specifies the number of colors currently stored nor does it specify a valid position inside the range of pre-existing colors, the behaviour is undefined!

Note:
The behavior is undefined if either fdim doesn't match the correct dimension, in terms of float, of the colors pointed to by cols, or cols is an invalid pointer, or count exceeds the actual number of source colors.
Parameters:
fdim | Dimension of colors, in terms of float
pos | Start position inside the range of pre-existing colors.
cols | Address of source colors
count | Number of colors to copy

size_t getNumberOfSecondaryColors ( void ) const [inline]

Get number of secondary colors.

Returns:
The number of secondary colors.

const float * getSecondaryColors ( void ) const [inline]

Get constant pointer to secondary colors.

Returns:
A pointer to the secondary colors.

unsigned int getSecondaryColorsDim ( void ) const [inline]

Get the dimension of the secondary colors.

Returns:
The dimension of the secondary colors stored. If there are no secondary colors stored, the function returns 0.

void setSecondaryColors | ( | unsigned int | fdim,
 |  | const float * | cols,
 |  | size_t | count
 | ) | [inline]

Set secondary colors for this VertexAttributeSet.

Copies count colors of dimension fdim from the location pointed to by cols to this VertexAttributeSet.
Valid values for fdim are 3 and 4.

Note:
The behavior is undefined if either fdim doesn't match the correct dimension, in terms of float, of the colors pointed to by cols, or if cols is an invalid pointer, or if count exceeds the actual number of source colors.
Parameters:
fdim | Dimension of colors, in terms of float.
cols | Address of source colors.
count | Number of colors to copy.

void setSecondaryColors | ( | unsigned int | fdim,
 |  | size_t | pos,
 |  | const float * | cols,
 |  | size_t | count
 | ) | [inline]

Set secondary colors for this VertexAttributeSet.

Copies count colors of dimension fdim from the location pointed to by cols to this VertexAttributeSet, starting at position pos inside the range of pre-existing colors. Valid values for fdim are 3 and 4. Pre-existing colors in the range [pos, pos + count) will be replaced. Pre-existing colors outside this range remain untouched. If you specify -1 for pos or if pos specifies the number of colors currently stored the colors pointed to by cols will be appended to the pre-existing colors. If you not specify -1 for pos or pos neither specifies the number of colors currently stored nor does it specify a valid position inside the range of pre-existing colors, the behaviour is undefined!

Note:
The behavior is undefined if either fdim doesn't match the correct dimension, in terms of float, of the colors pointed to by cols, or cols is an invalid pointer, or count exceeds the actual number of source colors.
Parameters:
fdim | Dimension of colors, in terms of float
pos | Start position inside the range of pre-existing colors.
cols | Address of source colors
count | Number of colors to copy

size_t getNumberOfFogCoords ( void ) const [inline]

Get number of fog coordinates.

Returns:
The number of fog coordinates.

const float * getFogCoords ( void ) const [inline]

Get fog coordinates.

Returns:
A pointer to the fog coordiantes.

void setFogCoords | ( | const float * | coords,
 |  | size_t | count
 | ) | [inline]

Set the fog coordinates.

Copies count fog coordinates from the location pointed to by coords to this VertexAttributeSet.

Note:
The behaviour is undefined if either coords is an invalid pointer, or count exceeds the actual number of source coordinates.
Parameters:
coords | Address of source coordinates.
count | Number of coordinates to copy.

void setFogCoords | ( | size_t | pos,
 |  | const float * | coords,
 |  | size_t | count
 | ) | [inline]

Set the fog coordinates.

Copies count fog coordinates from the location pointed to by coords to this VertexAttributeSet, starting at position pos inside the range of pre-existing coordinates. Pre-existing coordinates in the range [pos, pos + count) will be replaced. Pre-existing coordinates outside this range remain untouched. If you specify -1 for pos or if pos specifies the number of coordinates currently stored the coordinates pointed to by coords will be appended to the pre-existing coordinates. If you not specify -1 for pos or pos neither specifies the number of coordinates currently stored nor does it specify a valid position inside the range of pre-existing coordinates, the behaviour is undefined!

Note:
The behaviour is undefined if either coords is an invalid pointer, or count exceeds the actual number of source coordinates.
Parameters:
pos | Start position inside the range of pre-existing coordinates
coords | Address of source coordinates.
count | Number of coordinates to copy.

size_t getNumberOfOwners ( void ) const [inline]

Get the number of owners of this VertexAttributeSet.

Returns:
The number of owners if this VertexAttributeSet

const PrimitiveSet * getOwner ( size_t index ) const [inline]

Get a constant pointer to the owner at position index.

Returns:
The constant pointer to the owner at position index
Parameters:
index The position to get the owner at

NVSG_API VertexAttributeSet& operator= ( const VertexAttributeSet & rhs )

Assignement operator.

Performs a deep copy.

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.

virtual NVSG_API void invalidateIncarnation ( void ) [protected, virtual]

Invalidate the Incarnation.

This function is called from the framework when the Incarnation of this VertexAttributeSet has increased and now is to be marked as invalid. It first increases the Incarnation of all it's owners, then it's own Incarnation is marked as invalid.

Reimplemented from Object.

Friends And Related Function Documentation

NVSG_API void generateTexCoords | ( | VertexAttributeSet * | vas,
 |  | TextureCoordType | tct,
 |  | const nvmath::Sphere3f & | sphere,
 |  | size_t | 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 Fri Aug 4 08:39:01 2006 for NVSGSDK by NVIDIA


Member List

VertexAttributeSet Member List

This is the complete list of members for VertexAttributeSet, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clearTexCoords(size_t texUnit) | VertexAttributeSet | [inline]
clearVertexAttributeData(size_t attrib) | VertexAttributeSet |
clone(void) const | VertexAttributeSet | [virtual]
create(void) | VertexAttributeSet | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
F1F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
FOG_COORDINATE enum value (defined in VertexAttributeSet) | VertexAttributeSet |
generateTexCoords(VertexAttributeSet *vas, TextureCoordType tct, const nvmath::Sphere3f &sphere, size_t tu=0) | VertexAttributeSet | [related]
getColors(void) const | VertexAttributeSet | [inline]
getColorsDim(void) const | VertexAttributeSet | [inline]
getDataID(void) const | VertexAttributeSet | [virtual]
getDeviceAbstractionLinkData(unsigned int dataID, DALDataType *&cache, TestFunc test) const | DALHost | [inline]
getFogCoords(void) const | VertexAttributeSet | [inline]
getHigherLevelObjectCode(unsigned int oc) const | Object | [virtual]
getIncarnation() const | Object |
getInterleavedFormat() const | VertexAttributeSet | [inline]
getLastRecentlyUsedDeviceAbstractionLinkData() const | DALHost | [inline]
getName() const | Object |
getNormals(void) const | VertexAttributeSet | [inline]
getNumberOfColors(void) const | VertexAttributeSet | [inline]
getNumberOfFogCoords(void) const | VertexAttributeSet | [inline]
getNumberOfNormals(void) const | VertexAttributeSet | [inline]
getNumberOfOwners(void) const | VertexAttributeSet | [inline]
getNumberOfSecondaryColors(void) const | VertexAttributeSet | [inline]
getNumberOfTexCoords(size_t texUnit) const | VertexAttributeSet | [inline]
getNumberOfVertexAttributeBytes(size_t attrib) const | VertexAttributeSet |
getNumberOfVertexAttributeData(size_t attrib) const | VertexAttributeSet | [inline]
getNumberOfVertices(void) const | VertexAttributeSet | [inline]
getObjectCode() const | Object | [inline]
getOwner(size_t index) const | VertexAttributeSet | [inline]
getSecondaryColors(void) const | VertexAttributeSet | [inline]
getSecondaryColorsDim(void) const | VertexAttributeSet | [inline]
getTexCoords(size_t texUnit) const | VertexAttributeSet | [inline]
getTexCoordsDim(size_t texUnit) const | VertexAttributeSet | [inline]
getVertexAttributeData(size_t attrib) const | VertexAttributeSet | [inline]
getVertexAttributeDataDim(size_t attrib) const | VertexAttributeSet | [inline]
getVertices(void) const | VertexAttributeSet | [inline]
hasTexCoords(void) const | VertexAttributeSet | [inline]
IAllocator() | IAllocator | [inline]
increaseIncarnation() | Object |
invalidateIncarnation(void) | VertexAttributeSet | [protected, virtual]
isDataShared(void) const | VertexAttributeSet | [virtual]
isEquivalent(const Object *p, bool ignoreNames, bool deepCompare) const | VertexAttributeSet | [virtual]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
m_objectCode | Object | [protected]
markUnshareable() | RCObject | [inline]
N3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NORMAL enum value (defined in VertexAttributeSet) | VertexAttributeSet |
NUMBER_OF_VERTEX_ATTRIBUTES enum value (defined in VertexAttributeSet) | VertexAttributeSet |
Object() | Object | [protected]
Object(const Object &rhs) | Object | [protected]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const VertexAttributeSet &rhs) | VertexAttributeSet |
nvsg::Object::operator=(const Object &rhs) | Object | [protected]
nvsg::nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
PRIMARY_COLOR enum value (defined in VertexAttributeSet) | VertexAttributeSet |
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
releaseDeviceAbstractionLinkData() | DALHost | [inline]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
SECONDARY_COLOR enum value (defined in VertexAttributeSet) | VertexAttributeSet |
setColors(unsigned int fdim, const float *cols, size_t count) | VertexAttributeSet | [inline]
setColors(unsigned int fdim, size_t pos, const float *cols, size_t count) | VertexAttributeSet | [inline]
setFogCoords(const float *coords, size_t count) | VertexAttributeSet | [inline]
setFogCoords(size_t pos, const float *coords, size_t count) | VertexAttributeSet | [inline]
setName(const std::string &name) | Object |
setNormals(const nvmath::Vec3f *nor, size_t count) | VertexAttributeSet | [inline]
setNormals(size_t pos, const nvmath::Vec3f *nor, size_t count) | VertexAttributeSet | [inline]
setSecondaryColors(unsigned int fdim, const float *cols, size_t count) | VertexAttributeSet | [inline]
setSecondaryColors(unsigned int fdim, size_t pos, const float *cols, size_t count) | VertexAttributeSet | [inline]
setTexCoords(size_t texUnit, unsigned int fdim, const float *coords, size_t count) | VertexAttributeSet | [inline]
setTexCoords(size_t texUnit, unsigned int fdim, size_t pos, const float *coords, size_t count) | VertexAttributeSet | [inline]
setVertexAttributeData(size_t attrib, unsigned int fdim, const float *fdata, size_t count) | VertexAttributeSet |
setVertexAttributeData(size_t attrib, unsigned int fdim, size_t pos, const float *fdata, size_t count) | VertexAttributeSet |
setVertices(const nvmath::Vec3f *verts, size_t count) | VertexAttributeSet | [inline]
setVertices(size_t pos, const nvmath::Vec3f *verts, size_t count) | VertexAttributeSet | [inline]
storeDeviceAbstractionLinkData(unsigned int dataID, DALData *data) const | DALHost | [inline]
SVC3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
SVC4F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T01F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T02F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T03F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T11F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T12F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T13F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T21F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T22F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T23F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T31F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T32F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T33F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T41F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T42F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T43F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T51F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T52F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T53F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T61F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T62F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T63F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T71F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T72F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
T73F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_0 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_3 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_4 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_5 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_6 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
TEXTURE_COORD_7 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
theAllocator typedef | IAllocator |
UNUSED_1 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
UNUSED_2 enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F_T2F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F_T2F_TG3F_BN3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F_VC3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F_VC3F_T2F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F_VC4F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
V3F_N3F_VC4F_T2F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
validateIncarnation() const | Object | [protected, virtual]
VC3F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
VC4F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
VERTEX_POSITION enum value (defined in VertexAttributeSet) | VertexAttributeSet |
VERTEX_WEIGHTS enum value (defined in VertexAttributeSet) | VertexAttributeSet |
VertexAttributeSet(void) | VertexAttributeSet | [protected]
VertexAttributeSet(const VertexAttributeSet &rhs) | VertexAttributeSet | [protected]
VW1F enum value (defined in VertexAttributeSet) | VertexAttributeSet |
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~Object() | Object | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~VertexAttributeSet(void) | VertexAttributeSet | [protected, virtual]
Generated on Fri Aug 4 08:39:01 2006 for NVSGSDK by NVIDIA


VertexAttributeSetUnifyTraverser Class Reference

Optimizing Traverser that unifies VertexAttributeSets. More...

#include <VertexAttributeSetUnifyTraverser.h>

Inheritance diagram for VertexAttributeSetUnifyTraverser:

[legend]
Collaboration diagram for VertexAttributeSetUnifyTraverser:

[legend]
List of all members.

Public Member Functions

NVSG_API | VertexAttributeSetUnifyTraverser (void)
Constructor.

Protected Member Functions

virtual NVSG_API | ~VertexAttributeSetUnifyTraverser (void)
Protected destructor to prevent instantiation of a PrimitiveSetUnifyTraverser on stack.

virtual NVSG_API void | doApply (const nvsg::Scene *pScene)
clear temporary storage after traversing

virtual NVSG_API void | traversePrimitiveSet (const nvsg::PrimitiveSet *p)
This function will be called from the framework when a PrimitiveSet is visited.

Detailed Description

Optimizing Traverser that unifies VertexAttributeSets.

Maps identical VertexAttributeSets to the same one.

Constructor & Destructor Documentation

NVSG_API VertexAttributeSetUnifyTraverser ( void )

Constructor.

virtual NVSG_API ~VertexAttributeSetUnifyTraverser ( void ) [protected, virtual]

Protected destructor to prevent instantiation of a PrimitiveSetUnifyTraverser on stack.

Member Function Documentation

virtual NVSG_API void doApply ( const nvsg::Scene * pScene ) [protected, virtual]

clear temporary storage after traversing

Reimplemented from OptimizeTraverser.

virtual NVSG_API void traversePrimitiveSet ( const nvsg::PrimitiveSet * p ) [protected, virtual]

This function will be called from the framework when a PrimitiveSet is visited.

remarks Custom traversers can override this function for special tasks that need to be performed when visiting a PrimitiveSet object.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • VertexAttributeSetUnifyTraverser.h
Generated on Fri Aug 4 08:39:51 2006 for NVSGSDK by NVIDIA


Member List

VertexAttributeSetUnifyTraverser Member List

This is the complete list of members for VertexAttributeSetUnifyTraverser, including all inherited members.
addObjectHandler(unsigned int objectCode, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *pScene) | VertexAttributeSetUnifyTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | VertexAttributeSetUnifyTraverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
VertexAttributeSetUnifyTraverser(void) | VertexAttributeSetUnifyTraverser |
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
~VertexAttributeSetUnifyTraverser(void) | VertexAttributeSetUnifyTraverser | [protected, virtual]
Generated on Fri Aug 4 08:39:51 2006 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 (const nvsg::Scene *scene)
Initiate traversal of the scene with a view state.

void | handleVertexAttributeSet (const nvsg::VertexAttributeSet *p)
Unify all VertexAttributeSets.

void | handleAnimatedQuads (const nvsg::AnimatedQuads *p)
Explicitly nop on Animated and Skinned Primitives.

void | handleAnimatedTriangles (const nvsg::AnimatedTriangles *p)
Routine to handle a AnimatedTriangles object while traversing the scene graph.

void | handleSkinnedTriangles (const nvsg::SkinnedTriangles *p)
Routine to handle a SkinnedTriangles object while traversing the scene graph.

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 ( const nvsg::Scene * scene ) [protected, virtual]

Initiate traversal of the scene with a view state.

Calculates the tolerance for the scene and calls the Traverser::doApply().

Parameters:
scene Scene to traverse and handle

Reimplemented from OptimizeTraverser.

void handleVertexAttributeSet ( const nvsg::VertexAttributeSet * p ) [protected, virtual]

Unify all VertexAttributeSets.

Reimplemented from Traverser.

void handleAnimatedQuads ( const nvsg::AnimatedQuads * p ) [protected, virtual]

Explicitly nop on Animated and Skinned Primitives.

Reimplemented from Traverser.

void handleAnimatedTriangles ( const nvsg::AnimatedTriangles * p ) [protected, virtual]

Routine to handle a AnimatedTriangles object while traversing the scene graph.

This routine gets called for each AnimatedTriangles object that will be visited while traversing the scene graph. The currently visited AnimatedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

void handleSkinnedTriangles ( const nvsg::SkinnedTriangles * p ) [protected, virtual]

Routine to handle a SkinnedTriangles object while traversing the scene graph.

This routine gets called for each SkinnedTriangles object that will be visited while traversing the scene graph. The currently visited SkinnedTriangles object is pointed to by p. The base implementation ensures that all underlying components will be traversed in a correct way. For derived classes, it is recommended to always call the base implementation for traversing purposes.

Note:
The behavior is undefined if p points to an invalid location.

Reimplemented from Traverser.

The documentation for this class was generated from the following file:
  • VertexUnifyTraverser.h
Generated on Fri Aug 4 08:39:53 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *scene) | VertexUnifyTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getIgnoreNames(void) const | OptimizeTraverser | [inline]
getProblems() | Traverser |
getTreeModified(void) const | OptimizeTraverser | [inline]
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | VertexUnifyTraverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | Traverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | VertexUnifyTraverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | Traverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | VertexUnifyTraverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | Traverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | VertexUnifyTraverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
OptimizeTraverser(void) | OptimizeTraverser |
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
setTreeModified(void) (defined in OptimizeTraverser) | OptimizeTraverser | [inline, protected]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
VertexUnifyTraverser(void) | VertexUnifyTraverser |
wasTraversalInterrupted() | Traverser | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~OptimizeTraverser(void) | OptimizeTraverser | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
~VertexUnifyTraverser(void) | VertexUnifyTraverser | [protected, virtual]
Generated on Fri Aug 4 08:39:53 2006 for NVSGSDK by NVIDIA


ViewState Class Reference

The ViewState class encapsulates the view-specific states. More...

#include <ViewState.h>

Inheritance diagram for ViewState:

[legend]
Collaboration diagram for ViewState:

[legend]
List of all members.

Public Member Functions

NVSG_API const ViewState * | clone () const
Create a new ViewState by copying from this.

NVSG_API void | setAnimationFrame (size_t frame)
set the current animation frame number.

NVSG_API size_t | getAnimationFrame () const
Get the current animation frame number.

NVSG_API bool | isAnimating () const
Test if there is currently an animation running.

NVSG_API void | setAnimation (bool state)
Set the animation state of this view.

NVSG_API void | setCamera (const Camera *camera)
Set the camera for this view.

NVSG_API const Camera * | getCamera () const
Get the current camera.

NVSG_API bool | isJitter () const
Test if the view is in jitter mode.

NVSG_API size_t | getNumberOfJitters () const
Get the number of jitters set for this view.

NVSG_API void | setJitter (bool on, const std::vector< nvmath::Vec2f > &jitters)
Set the camera jitter information for this view.

NVSG_API const nvmath::Vec2f * | getJitters () const
Retrieve the currently used jitter values.

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 () const
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 const MapList * | getMapList () const
Get the current MapList.

NVSG_API void | setMapList (const MapList *ml)
Set the MapList.

Static Public Member Functions

NVSG_API const ViewState * | create ()
Create a ViewState.

Protected Member Functions

NVSG_API | ViewState ()
Protected default constructor to prevent explicit creation.

NVSG_API | ViewState (const ViewState &rhs)
Protected copy constructor to prevent explicit creation.

virtual NVSG_API | ~ViewState ()
Protected destructor to prevent explicit creation on stack.

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

Constructor & Destructor Documentation

NVSG_API ViewState ( ) [protected]

Protected default constructor to prevent explicit creation.

Remarks:
A default-constructed ViewState has no camera attached!

NVSG_API ViewState ( const ViewState & rhs ) [protected]

Protected copy constructor to prevent explicit creation.

Remarks:
The new constructed ViewState will not inherit the cull-data tree from the source ViewState - that means that the cull-data tree for the new constructed ViewState initially is cleared!

virtual NVSG_API ~ViewState ( ) [protected, virtual]

Protected destructor to prevent explicit creation on stack.

Member Function Documentation

NVSG_API const ViewState* create ( ) [static]

Create a ViewState.

Returns:
A pointer to a constant ViewState.
Remarks:
A ViewState with the following properties is created:
  • No animation running
  • No camera defined
  • No jitter
  • No stereo
  • No LOD range scaling
  • No cull information

NVSG_API const ViewState* clone ( ) const

Create a new ViewState by copying from this.

Returns:
A pointer to a constant ViewState.
Remarks:
The newly created ViewState is an exact copy of this.

The new copy does not inherit this ViewState's cull information but will initially have its cull tree cleared!

void setAnimationFrame ( size_t frame ) [inline]

set the current animation frame number.

Parameters:
frame Null-based animation frame number.
Remarks:
Set the number of the animation frame that should be used for rendering.
See also:
getAnimationFrame

size_t getAnimationFrame ( ) const [inline]

Get the current animation frame number.

Returns:
Null-based animation frame number.
Remarks:
This function can be used to retrieve the current animation frame number.
See also:
setAnimationFrame

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:
setAnimation

void setAnimation ( bool state ) [inline]

Set the animation state of this view.

Parameters:
state 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->setAnimation(true);
    endEdit(ncViewState);

    m_animationManip = new AnimationManipulator;
    m_animationManip->setRenderArea(m_pRA);

    // We need to ask the scene for the complete numbers of frames.
    // Do not forget - there could be other animations even when there is no camera animation!
    m_animationManip->setNumberOfFrames(GetDocument()->getScene()->getNumberOfFrames());

    // Could be NULL, if there is no camera animation
    m_animationManip->setCameraAnimation(GetDocument()->getScene()->getCameraAnimation());
  }
  else
  {
    ViewState * ncViewState = beginEdit(viewState);
      ncViewState->setAnimation(false);
    endEdit(ncViewState);

    if (m_animationManip)
    {
      delete m_animationManip;
      m_animationManip = NULL;
    }
  }
  [...]
See also:
nvui::AnimationManipulator, isAnimating

void setCamera ( const Camera * camera ) [inline]

Set the camera for this view.

Parameters:
camera Pointer to a constant Camera object.
Remarks:
The given camera is used for the rendering.
See also:
getCamera

const Camera * getCamera ( ) const [inline]

Get the current camera.

Returns:
A pointer to the constant camera which is used in this view. If there is no camera associated with this view, the return value is 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 position. This mode can be used for software full-screen antialiasing, or motion blur, etc.
See also:
setJitter, getJitters, getNumberOfJitters

size_t getNumberOfJitters ( ) const [inline]

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, setJitter, getJitters

void setJitter | ( | bool | on,
 |  | const std::vector< nvmath::Vec2f > & | jitters
 | ) | [inline]

Set the camera jitter information for this view.

Parameters:
on | Set this parameter to true if you want to turn on camera jittering.
jitters | Vector of two-dimensional displacement vectors.
Remarks:
Jitter values can be used for performing software full-screen antialiasing, for example. The displacements represent the number of pixels or fragment of the pixel the camera is jittered in the x- and y-direction in screen space to achieve the effect.
Every jitter entry leads to a new rendering pass with the slightly moved camera.
Example
This example shows how to set up 2x software FSAA (two pass rendering):
  [...]
  // set the jitter technique, in this case use the accumulation buffer
  RenderTraverser * renderTraverser = m_pRA->getRenderTraverser();
  renderTraverser->setJitterTechnique(JT_ACCUM);

  // define the small camera offsets (jitter)
  vector<Vec2f>
  jitter.resize(2); // 2x fsaa
  jitter[0] = Vec2f(0.25f, 0.75f);  // first pass
  jitter[1] = Vec2f(0.75f, 0.25f);  // second pass
  ViewState * viewState = beginEdit(m_pRA->getViewState());
    viewState->setJitter(true, jitter);
  endEdit( viewState );
  [...]
See also:
getJitters, getNumberOfJitters, isJitter RenderTraverser::setJitterTechnique, RenderTraverser::JitterTechnique

const nvmath::Vec2f * getJitters ( ) const [inline]

Retrieve the currently used jitter values.

Returns:
Pointer to a constant array of jitter vectors (first element). If there are no jitters defined, the return value is NULL.
Remarks:
This function can be used to retrieve the currently used offsets for the camera jittering. The application should call ViewState::getNumberOfJitters to determine the size of the array containing the jitter values.
See also:
setJitter, 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 ( ) const

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

void setCullTree ( const CullData * cullTree ) [inline]

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

const MapList * getMapList ( ) const [inline]

Get the current MapList.

Returns:
A pointer to a constant 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 ( const MapList * ml ) [inline]

Set the MapList.

Returns:
A pointer to a constant MapList.
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

The documentation for this class was generated from the following file:
  • ViewState.h
Generated on Fri Aug 4 08:39:03 2006 for NVSGSDK by NVIDIA


Member List

ViewState Member List

This is the complete list of members for ViewState, including all inherited members.
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
clearCullTree() const | ViewState |
clone() const | ViewState |
create() | ViewState | [static]
doneReading() const | ISWMRSync | [inline]
doneWriting() const | ISWMRSync | [inline]
getAnimationFrame() const | ViewState | [inline]
getCamera() const | ViewState | [inline]
getCullTree() const | ViewState | [inline]
getJitters() const | ViewState | [inline]
getLODRangeScale() const | ViewState | [inline]
getMapList() const | ViewState | [inline]
getNumberOfJitters() const | ViewState | [inline]
getStereoAutomaticEyeDistanceFactor() const | ViewState | [inline]
getStereoEyeDistance() const | ViewState | [inline]
getTargetDistance() const | ViewState | [inline]
IAllocator() | IAllocator | [inline]
isAnimating() const | ViewState | [inline]
isJitter() const | ViewState | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
isStereo() const | ViewState | [inline]
isStereoAutomaticEyeDistanceAdjustment() const | ViewState | [inline]
isStereoReversedEyes() const | ViewState | [inline]
ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected]
ISWMRSync(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
nvutil::RCObject::operator=(const RCObject &rhs) | RCObject | [inline, protected]
operator=(const ISWMRSync &) (defined in ISWMRSync) | ISWMRSync | [protected]
RCObject() | RCObject | [inline, protected]
RCObject(const RCObject &rhs) | RCObject | [inline, protected]
removeOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
removeRef() const | RCObject | [inline]
setAnimation(bool state) | ViewState | [inline]
setAnimationFrame(size_t frame) | ViewState | [inline]
setCamera(const Camera *camera) | ViewState | [inline]
setCullTree(const CullData *cullTree) | ViewState | [inline]
setJitter(bool on, const std::vector< nvmath::Vec2f > &jitters) | ViewState | [inline]
setLODRangeScale(float factor) | ViewState | [inline]
setMapList(const MapList *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]
stereoReverseEyes() | ViewState | [inline]
theAllocator typedef | IAllocator |
toggleStereo() | ViewState | [inline]
ViewState() | ViewState | [protected]
ViewState(const ViewState &rhs) | ViewState | [protected]
waitToRead() const | ISWMRSync | [inline]
waitToWrite() const | ISWMRSync | [inline]
~IAllocator() | IAllocator | [inline, virtual]
~ISWMRSync() (defined in ISWMRSync) | ISWMRSync | [protected, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~ViewState() | ViewState | [protected, virtual]
Generated on Fri Aug 4 08:39:03 2006 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.

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 Fri Aug 4 08:39:03 2006 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 | VNVector | [inline]
vertices | VNVector |
Generated on Fri Aug 4 08:39:03 2006 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 (size_t screenSizeX=1280, size_t 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.

NVSG_API bool | isWalk ()
Test if the Manipulator is in walk mode.

NVSG_API bool | isTranslate ()
Test if the Manipulator is in translate mode.

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.

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.

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 ecreasing 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.

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 | ( | size_t | screenSizeX = 1280,
 |  | size_t | 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.

NVSG_API bool isWalk ( )

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)

NVSG_API bool isTranslate ( )

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

NVSG_API bool isTilt ( )

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

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 ecreasing 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.

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 Fri Aug 4 08:40:06 2006 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]
getHSensitivity() | WalkCameraManipulator | [inline]
getSpeed() | WalkCameraManipulator | [inline]
getSpeedIncreaseFactor() | WalkCameraManipulator | [inline]
getWorldUpVector() | WalkCameraManipulator | [inline]
INCREASESPEED | WalkCameraManipulator | [protected, static]
isActive() | WalkCameraManipulator | [virtual]
isTilt() | WalkCameraManipulator |
isTranslate() | WalkCameraManipulator |
isWalk() | WalkCameraManipulator |
keyDown(UINT key) | WalkCameraManipulator |
keyUp(UINT key) | WalkCameraManipulator |
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 |
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]
TRANSLATE | WalkCameraManipulator | [protected, static]
updateFrame() | WalkCameraManipulator | [virtual]
WALKBACKWARD | WalkCameraManipulator | [protected, static]
WalkCameraManipulator(size_t screenSizeX=1280, size_t screenSizeY=1024) | WalkCameraManipulator |
WALKFORWARD | WalkCameraManipulator | [protected, static]
~Manipulator() | Manipulator | [virtual]
~WalkCameraManipulator() | WalkCameraManipulator |
Generated on Fri Aug 4 08:40:06 2006 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

void | deleteThis (void)
Realization of the pure virtual interface function of a PlugIn.

const nvsg::Scene * | load (const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&viewState)
Realization of the pure virtual interface function of a SceneLoader.

Detailed Description

A Scene Loader for wrl files.

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.

const nvsg::Scene* load | ( | const std::string & | filename,
 |  | const std::vector< std::string > & | searchPaths,
 |  | const nvsg::ViewState *& | viewState
 | ) |

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.

The documentation for this class was generated from the following file:
  • WRLLoader.h
Generated on Fri Aug 4 08:37:08 2006 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]
deleteThis(void) | WRLLoader | [inline, virtual]
load(const std::string &filename, const std::vector< std::string > &searchPaths, const nvsg::ViewState *&viewState) | WRLLoader |
nvsg::SceneLoader::load(const std::string &filename, const std::vector< std::string > &searchPaths, const ViewState *&viewState)=0 | SceneLoader | [pure virtual]
PlugIn() (defined in PlugIn) | PlugIn | [inline]
setCallback(PlugInCallback *cb, bool throwExceptionOnError=true) | PlugIn | [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 Fri Aug 4 08:37:08 2006 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 (const nvsg::Scene *pScene)
Entry point of the postprocessor of the WRLLoader.

virtual void | handleAnimatedTransform (const nvsg::AnimatedTransform *p)
Postprocessing on AnimatedTransform.

virtual void | handleBillboard (const nvsg::Billboard *p)
Postprocessing on Billboard.

virtual void | handleGroup (const nvsg::Group *p)
Postprocessing on Group.

virtual void | handleTransform (const 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 ( const nvsg::Scene * pScene ) [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 Traverser.

virtual void handleAnimatedTransform ( const 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 Traverser.

virtual void handleBillboard ( const 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 Traverser.

virtual void handleGroup ( const 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 Traverser.

virtual void handleTransform ( const 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 Traverser.

The documentation for this class was generated from the following file:
  • WRLLoadTraverser.h
Generated on Fri Aug 4 08:37:09 2006 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, HandlerType handler) | Traverser | [inline, protected]
addOnDestroyCallback(DestroyCallback *dcb, void *data) | RCObject | [inline]
addRef() const | RCObject | [inline]
apply(const nvsg::Scene *scene) | Traverser |
beginEdit(const T *obj) const | Traverser | [inline, protected]
doApply(const nvsg::Scene *pScene) | WRLLoadTraverser | [protected, virtual]
endEdit(const T *obj) const | Traverser | [inline, protected]
getProblems() | Traverser |
handleAnimatedQuads(const nvsg::AnimatedQuads *p) | Traverser | [protected, virtual]
handleAnimatedTransform(const nvsg::AnimatedTransform *p) | WRLLoadTraverser | [protected, virtual]
handleAnimatedTriangles(const nvsg::AnimatedTriangles *p) | Traverser | [protected, virtual]
handleBillboard(const nvsg::Billboard *p) | WRLLoadTraverser | [protected, virtual]
handleBitmap(const nvsg::Bitmap *p) | Traverser | [protected, virtual]
handleBlendAttribute(const nvsg::BlendAttribute *p) | Traverser | [protected, virtual]
handleCgFx(const nvsg::CgFx *p) | Traverser | [protected, virtual]
handleDepthAttribute(const nvsg::DepthAttribute *p) | Traverser | [protected, virtual]
handleDirectedLight(const nvsg::DirectedLight *p) | Traverser | [protected, virtual]
handleFaceAttribute(const nvsg::FaceAttribute *p) | Traverser | [protected, virtual]
handleFramedTrafoAnimation(const nvsg::FramedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleFramedVNVectorAnimation(const nvsg::FramedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleGeoNode(const nvsg::GeoNode *p) | Traverser | [protected, virtual]
handleGroup(const nvsg::Group *p) | WRLLoadTraverser | [protected, virtual]
handleHighlightBox(const nvsg::HighlightBox *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleHighlightEdges(const nvsg::HighlightEdges *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation< nvmath::Trafo > *p) | Traverser | [protected, virtual]
handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation< nvsg::VNVector > *p) | Traverser | [protected, virtual]
handleLineAttribute(const nvsg::LineAttribute *p) | Traverser | [protected, virtual]
handleLines(const nvsg::Lines *p) | Traverser | [protected, virtual]
handleLineStrips(const nvsg::LineStrips *p) | Traverser | [protected, virtual]
handleLOD(const nvsg::LOD *p) | Traverser | [protected, virtual]
handleMapArray(const nvsg::MapArray *p) | Traverser | [protected, virtual]
handleMapElement(const nvsg::MapElement *p) | Traverser | [protected, virtual]
handleMapList(const nvsg::MapList *p) | Traverser | [protected, virtual]
handleMapMatrix(const nvsg::MapMatrix *p) | Traverser | [protected, virtual]
handleMaterial(const nvsg::Material *p) | Traverser | [protected, virtual]
handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
handlePointAttribute(const nvsg::PointAttribute *p) | Traverser | [protected, virtual]
handlePointLight(const nvsg::PointLight *p) | Traverser | [protected, virtual]
handlePoints(const nvsg::Points *p) | Traverser | [protected, virtual]
handleQuadMeshes(const nvsg::QuadMeshes *p) | Traverser | [protected, virtual]
handleQuads(const nvsg::Quads *p) | Traverser | [protected, virtual]
handleQuadStrips(const nvsg::QuadStrips *p) | Traverser | [protected, virtual]
handleShape(const nvsg::Shape *p) | Traverser | [protected, virtual]
handleSkinnedTriangles(const nvsg::SkinnedTriangles *p) | Traverser | [protected, virtual]
handleSpotLight(const nvsg::SpotLight *p) | Traverser | [protected, virtual]
handleStatePass(const nvsg::StatePass *p) | Traverser | [protected, virtual]
handleStateSet(const nvsg::StateSet *p) | Traverser | [protected, virtual]
handleStateVariant(const nvsg::StateVariant *p) | Traverser | [protected, virtual]
handleSwitch(const nvsg::Switch *p) | Traverser | [protected, virtual]
handleTextureAttribute(const nvsg::TextureAttribute *p) | Traverser | [protected, virtual]
handleTextureAttributeItem(const nvsg::TextureAttributeItem *p, size_t tu) | Traverser | [protected, virtual]
handleTransform(const nvsg::Transform *p) | WRLLoadTraverser | [protected, virtual]
handleTriangles(const nvsg::Triangles *p) | Traverser | [protected, virtual]
handleTriFans(const nvsg::TriFans *p) | Traverser | [protected, virtual]
handleTriStrips(const nvsg::TriStrips *p) | Traverser | [protected, virtual]
handleVertexAttributeSet(const nvsg::VertexAttributeSet *p) | Traverser | [protected, virtual]
IAllocator() | IAllocator | [inline]
interruptTraversal() | Traverser | [inline]
isShareable() const | RCObject | [inline]
isShared() const | RCObject | [inline]
m_cullStack | Traverser | [protected]
m_interrupt | Traverser | [protected]
m_interrupted | Traverser | [protected]
m_lodStack | Traverser | [protected]
m_nullStateSet | Traverser | [protected]
m_problemLog | Traverser | [protected]
m_viewState | Traverser | [protected]
markUnshareable() | RCObject | [inline]
operator delete(void *p, size_t size) | IAllocator | [inline]
operator new(size_t size) | IAllocator | [inline]
operator new(size_t size, void *p) | IAllocator | [inline]
operator=(const RCObject &rhs) | RCObject | [inline, protected]
postApply(const nvsg::Node *root) | Traverser | [protected, virtual]
postTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
postTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
postTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
postTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
postTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
postTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | Traverser | [protected, virtual]
preApply(const nvsg::Node *root) | Traverser | [protected, virtual]
preTraverseDrawable(const nvsg::Drawable *p) | Traverser | [protected, virtual]
preTraverseDrawables(const nvsg::GeoNode *p, size_t i) | Traverser | [protected, virtual]
preTraverseGroup(const nvsg::Group *p) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapArray *p, size_t index) | Traverser | [protected, virtual]
preTraverseMap(const nvsg::MapMatrix *p, size_t col, size_t row) | Traverser | [protected, virtual]
preTraverseMapColumn(const nvsg::MapMatrix *p, size_t col) | Traverser | [protected, virtual]
preTraverseRoot(const nvsg::Camera *p, const nvsg::Node *root) | 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]
theAllocator typedef | IAllocator |
traverseHighlightObject(const nvsg::HighlightObject *p, const nvsg::PrimitiveSet *primitive) | Traverser | [protected, virtual]
traverseLight(const nvsg::LightSource *p) | Traverser | [protected, virtual]
traverseObject(const nvsg::Object *object) | Traverser | [inline, protected]
traverseObject(const nvsg::Object *object, T arg) | Traverser | [inline, protected]
traversePrimitiveSet(const nvsg::PrimitiveSet *p) | Traverser | [protected, virtual]
Traverser(bool readOnly=true) | Traverser | [protected]
wasTraversalInterrupted() | Traverser | [inline]
WRLLoadTraverser() | WRLLoadTraverser |
~IAllocator() | IAllocator | [inline, virtual]
~RCObject() | RCObject | [inline, protected, virtual]
~Traverser(void) | Traverser | [protected, virtual]
~WRLLoadTraverser(void) | WRLLoadTraverser | [virtual]
Generated on Fri Aug 4 08:37:09 2006 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
    • nvtraverser::CombinableResult
    • DenormalizedNormalsResult
    • EmptyResult
    • EquivalenceResult
    • IdentityResult
    • MissingResult
    • NullNormalsResult
    • ShortStrippedResult
    • SingleChildResult
  • Bit
  • Bone
  • bone_t
  • Chunk
  • DALData
    • nvgl::GLDALData
  • DALDataCreator
    • nvgl::GLDALDataCreator
  • DALHost
    • Object
      • Animation
        • FramedAnimation
        • InterpolatedAnimation
          • LinearInterpolatedAnimation
      • Camera
        • ParallelCamera
        • PerspectiveCamera
      • Drawable
        • PrimitiveSet
          • IndependentPrimitiveSet
            • Lines
            • Points
            • Quads
              • AnimatedQuads
            • Triangles
              • AnimatedTriangles
              • SkinnedTriangles
          • MeshedPrimitiveSet
            • QuadMeshes
          • StrippedPrimitiveSet
            • LineStrips
            • QuadStrips
            • TriFans
            • TriStrips
        • Shape
      • HighlightObject
        • HighlightBox
        • HighlightEdges
      • Map
        • Bitmap
      • MapList
      • MapObject
        • MapArray
        • MapElement
        • MapMatrix
      • Node
        • GeoNode
        • Group
          • Billboard
          • LOD
          • Switch
          • Transform
            • AnimatedTransform
        • LightSource
          • DirectedLight
          • PointLight
          • SpotLight
      • StateAttribute
        • BlendAttribute
        • CgFx
        • DepthAttribute
        • Material
        • PrimitiveAttribute
          • FaceAttribute
          • LineAttribute
          • PointAttribute
        • TextureAttribute
      • StatePass
      • StateSet
      • StateVariant
      • TextureAttributeItem
      • VertexAttributeSet
    • TextureImage
  • Face
  • FixedAllocator
  • FRAGOUT
  • geometrySet_t
  • GLArrayBufferCache
  • GLContext
  • GLDisplayListCache
  • GLElementArrayBufferCache
  • GLFunctions
  • GLObjects
  • GLTextureCache
  • IAllocator
    • CullData
    • RCObject
      • Object
      • Path
      • ScaleFilter
        • BellFilter
        • BoxFilter
        • BSplineFilter
        • Lanczos3Filter
        • TriangleFilter
      • Scene
      • TextureAttributeItemData
      • TextureImage
      • ViewState
      • Traverser
        • NBFSaveTraverser
        • NVBLoadTraverser
        • NVSGSaveTraverser
        • AnalyzeTraverser
        • DestrippingTraverser
        • ModelViewTraverser
          • AppTraverser
          • CullTraverser
            • FrustumCullTraverser
          • RayIntersectTraverser
          • RenderTraverser
            • GLTraverser
        • NormalizeTraverser
        • OptimizeTraverser
          • GeoNodeCombineTraverser
          • GeoNodeUnifyTraverser
          • GroupEliminateTraverser
          • IdentityToGroupTraverser
          • LODCombineTraverser
          • LODEliminateTraverser
          • PrimitiveSetCombineTraverser
          • PrimitiveSetUnifyTraverser
          • StateSetUnifyTraverser
          • SwitchToGroupTraverser
          • TransformCombineTraverser
          • VertexAttributeSetUnifyTraverser
          • VertexUnifyTraverser
        • SearchTraverser
        • SmoothTraverser
        • StrippingTraverser
        • TriangulateTraverser
        • WRLLoadTraverser
      • PlugInCallback
      • RCVector
  • Incarnation
  • IndexMesh
  • indexSet_t
  • Intersection
  • ISWMRSync
    • CgFxEffect
    • Object
    • Scene
    • TextureImage
    • ViewState
    • Lockable
  • KeyInput
  • keyVariant_t
  • Log
  • LogListCompare
  • Manipulator
    • AnimationManipulator
    • FlightCameraManipulator
    • TrackballCameraManipulator
    • TransformManipulator
      • TrackballTransformManipulator
    • WalkCameraManipulator
  • Matnnf
  • Matnnf< 3 >
    • Mat33f
  • Matnnf< 4 >
    • Mat44f
  • MemFunTbl
  • meshSet_t
  • MouseInput
  • NBFFramedAnimation
    • NBFFramedTrafoAnimation
    • NBFFramedVNVectorAnimation
  • NBFHeader
  • NBFInterpolatedAnimation
    • NBFInterpolatedTrafoAnimation
    • NBFInterpolatedVNVectorAnimation
  • NBFObject
    • NBFCamera
      • NBFParallelCamera
      • NBFPerspectiveCamera
    • NBFDrawable
      • NBFPrimitiveSet
        • NBFIndependentPrimitiveSet
          • NBFAnimatedIndependents
          • NBFSkinnedTriangles
        • NBFMeshedPrimitiveSet
        • NBFStrippedPrimitiveSet
    • NBFNode
      • NBFGeoNode
      • NBFGroup
        • NBFBillboard
        • NBFLOD
        • NBFSwitch
        • NBFTransform
          • NBFAnimatedTransform
      • NBFLightSource
        • NBFDirectedLight
        • NBFPointLight
        • NBFSpotLight
    • NBFStateAttribute
      • NBFBlendAttribute
      • NBFCgFx
      • NBFDepthAttribute
      • NBFFaceAttribute
      • NBFLineAttribute
      • NBFMaterial
      • NBFPointAttribute
      • NBFTextureAttribute
    • NBFStatePass
    • NBFStateSet
    • NBFStateVariant
    • NBFTextureAttributeItem
    • NBFTrafoAnimation
      • NBFFramedTrafoAnimation
      • NBFInterpolatedTrafoAnimation
    • NBFVertexAttributeSet
    • NBFVNVectorAnimation
      • NBFFramedVNVectorAnimation
      • NBFInterpolatedVNVectorAnimation
  • NBFScene
  • NBFViewState
  • NVNVB
  • NVSGException
  • NVSGLight
  • NVSGMaterial
  • Offset_AutoPtr
  • Plane3f
  • plane_t
  • PlugIn
    • SceneLoader
      • NBFLoader
      • NVBLoader
      • NVSGLoader
      • WRLLoader
    • SceneSaver
      • NBFSaver
      • NVSGSaver
    • TextureLoader
      • ILTexLoader
  • PlugInCallback::EmptyTokenInfo
  • PlugInCallback::FileAccessFailedInfo
  • PlugInCallback::FileMappingFailedInfo
  • PlugInCallback::IncompatibleFileInfo
  • PlugInCallback::IncompatibleValueInfo
  • PlugInCallback::InvalidFileInfo
  • PlugInCallback::InvalidValueInfo
  • PlugInCallback::UndefinedTokenInfo
  • PlugInCallback::UnexpectedTokenInfo
  • PlugInCallback::UnknownTokenInfo
  • PlugInCallback::UnsupportedTokenInfo
  • PlugInServer
  • PointerReference
  • ProblemInfo
  • ProblemLog
  • Quatf
  • RCIPtr
  • RCObject_AutoPtr
  • RCPtr
  • RegVal
  • removeReference
  • RenderArea
    • GLWinRenderArea
      • GLMFCRAWnd
  • sampler_t
  • Singleton
  • Skin
  • skin_t
  • Sphere3f
  • std::vector
  • std::vector
  • std::vector
  • std::vector
  • std::vector
  • str_t
  • SWMRSync
  • texBinding_t
  • texCoordSet_t
  • texImage_t
  • Trace
  • traceConsoleDebugOutput
  • traceConsoleOutput
  • traceDebugOutput
  • traceFileConsoleOutput
  • traceFileDebugOutput
  • traceFileOutput
  • TraceFunctor
  • Trackball
  • Trafo
  • trafo_t
  • TransformStack
  • tweak_t
  • UPIID
  • UPITID
  • VariantIterator
  • Vecnf
  • Vecnf< 2 >
    • Vec2f
  • Vecnf< 3 >
    • Vec3f
  • Vecnf< 4 >
    • Vec4f
  • VNVector
  • VS_INPUT
  • VS_OUTPUT
Generated on Fri Aug 4 08:36:29 2006 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
  • _MULTISAMPLE : RenderArea
  • _NO_BTN_KEY : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _NONE : RayIntersectTraverser
  • _S_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _SHIFT_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _STEREO : RenderArea
  • _UNDEFINED : RenderArea
  • _W_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _X_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _Y_KEY : TrackballTransformManipulator, TrackballCameraManipulator

- a -

  • activateClipPlane() : Group
  • active : plane_t
  • activeChildren : NBFSwitch
  • activeKey : NBFStateSet
  • addAttribute() : StateVariant, StateSet, StatePass
  • addBuffers() : GLObjects
  • addCamera() : Scene
  • addCameraAnimation() : Scene
  • addChild() : Group, CullData
  • addClipPlane() : Group
  • addEmptyColumn() : MapMatrix
  • addEntry() : MemFunTbl
  • addGeometry() : GeoNode
  • addHeadLight() : Camera
  • addHints() : Node
  • addLists() : GLObjects
  • addMap() : MapMatrix, MapArray
  • addMapObject() : MapList
  • addObjectHandler() : Traverser
  • addObjectRenderer() : RenderTraverser
  • addOcclusionQueries() : GLObjects
  • addOnDestroyCallback() : RCObject
  • addPass() : StateVariant, StateSet
  • addPlugInSearchPath : PlugInServer
  • addPrimitiveSet() : Shape
  • addPrograms() : GLObjects
  • addQueries() : GLObjects
  • addRef() : PointerReference, RCObject
  • addTextures() : GLObjects
  • addVariant() : StateSet
  • alloc() : Allocator, FixedAllocator, Chunk, Offset_AutoPtr, NBFSaveTraverser
  • Allocator() : Allocator
  • ambient : NVSGMaterial, NVSGLight
  • ambientColor : NBFLightSource, NBFScene
  • AnalyzeTraverser() : AnalyzeTraverser
  • AnimatedQuads() : AnimatedQuads
  • AnimatedTransform() : AnimatedTransform
  • AnimatedTriangles() : AnimatedTriangles
  • Animation() : Animation
  • animation : NBFLightSource, NBFAnimatedTransform, NBFAnimatedIndependents, bone_t
  • AnimationManipulator() : AnimationManipulator
  • antiAliasing : NBFPointAttribute, NBFLineAttribute
  • apply() : Trackball, Traverser
  • applyPass() : CgFxEffect
  • AppTraverser() : AppTraverser
  • AREAOFPEACE : WalkCameraManipulator, FlightCameraManipulator
  • areCollinear() : Vec3f
  • areOnOppositeSides() : Plane3f
  • areOnSameSide() : Plane3f
  • areOpposite() : Vecnf
  • areOrthogonal() : Vecnf
  • areOrthonormal() : Vecnf
  • areSimilar() : Vecnf
  • assertInvalidBoundingSphere() : Node
  • assignCustomLightToEffectLight() : RenderTraverser
  • assignDirectedLightToEffectLight() : RenderTraverser, GLTraverser
  • assignPointLightToEffectLight() : RenderTraverser, GLTraverser
  • assignSpotLightToEffectLight() : RenderTraverser, GLTraverser
  • attachHighlightObject() : Drawable
  • attachWindow() : GLWinRenderArea
  • attenuation : NBFSpotLight, NBFPointLight

- b -

  • backAmbientColor : NBFMaterial
  • backColor : NBFScene
  • backDiffuseColor : NBFMaterial
  • backEmissiveColor : NBFMaterial
  • backFaceMode : NBFFaceAttribute
  • backOpacity : NBFMaterial
  • backSpecularColor : NBFMaterial
  • backSpecularExponent : NBFMaterial
  • balance() : CullData
  • beginEdit() : Traverser
  • beginOcclusionCullQuery() : RenderTraverser, GLTraverser
  • Billboard() : Billboard
  • bindings : NBFTextureAttribute
  • bindTextureAttributeItem() : TextureAttribute
  • Bitmap() : Bitmap
  • BlendAttribute() : BlendAttribute
  • blocksAvailable() : Chunk
  • Bone() : Bone
  • bones : skin_t
  • boundingSphere() : Sphere3f
  • bpi : texImage_t
  • bpp : texImage_t
  • bps : texImage_t
  • byteOrder : NBFHeader

- c -

  • c() : Plane3f
  • calcNearFarDistances() : Camera
  • calculateBoundingSphere() : Transform, Switch, StrippedPrimitiveSet, Shape, PrimitiveSet, Node, MeshedPrimitiveSet, LightSource, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, Drawable
  • calculateTangentSpace() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • calculatingStorageRequirements() : NBFSaveTraverser
  • callback() : PlugIn
  • Camera() : Camera
  • camera : NBFViewState
  • cameraAnimations : NBFScene
  • cameras : NBFScene
  • castShadow : NBFLightSource
  • center : NBFLOD, trafo_t
  • CgFx() : CgFx
  • chars : str_t
  • checkClipPlanes() : RayIntersectTraverser
  • checkIntersection() : RayIntersectTraverser
  • children : NBFGroup
  • Chunk() : Chunk
  • clear() : MapList, MapArray
  • clearCullTree() : ViewState
  • clearGeometries() : GeoNode
  • clearHeadLights() : Camera
  • clearRenderLists() : RenderTraverser
  • clearTexCoords() : VertexAttributeSet, GeoNode
  • clearVertexAttributeData() : VertexAttributeSet
  • clipPlanes : NBFGroup
  • clone() : CullData, Intersection, ViewState, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Node, MeshedPrimitiveSet, Material, MapObject, MapMatrix, MapList, MapElement, MapArray, Map, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, IndependentPrimitiveSet, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Bitmap, Billboard, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • colorDim : NBFVertexAttributeSet
  • colors : NBFVertexAttributeSet
  • compileProgram() : CgFxEffect
  • constantAttenuation : NVSGLight
  • containsCgFx() : StateVariant, StateSet, StatePass, Scene, Node, Group, GeoNode
  • containsHints() : Node
  • containsLight() : Scene, Node, LightSource, Group
  • containsTransparentGeometry() : Scene, Node
  • context : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo
  • convert2DToCubeMap() : TextureImage
  • coordDim : texCoordSet_t
  • create() : ViewState, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, Scene, QuadStrips, Quads, QuadMeshes, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Material, MapMatrix, MapList, MapElement, MapArray, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, DirectedLight, DepthAttribute, CgFx, BlendAttribute, Bitmap, Billboard, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • createFromBase() : TriStrips, TriFans, Triangles, Transform, TextureAttribute, TextureAttributeItem, Switch, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, QuadStrips, Quads, QuadMeshes, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Material, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, DirectedLight, DepthAttribute, BlendAttribute, Billboard, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • createFromFile() : TextureImage, CgFxEffect
  • createFromLump() : CgFxEffect
  • createImage() : TextureImage
  • createMipmaps() : TextureImage
  • createNewRenderAreaID() : RenderArea
  • createOcclusionCullID() : RenderTraverser, GLTraverser
  • cullCode() : 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
  • decompose() : Quatf, Mat44f, Mat33f
  • DECREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • decrementMipmapUseCount() : TextureImage
  • deleteThis() : PlugIn, DALData, NVSGSaver, NBFSaver, WRLLoader, 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
  • determinant() : Mat33f
  • determineCullCode() : PerspectiveCamera, ParallelCamera, Camera
  • determineHintsContainment() : Switch, Node, Group
  • determinePixelFormat() : GLWinRenderArea
  • determineTransparencyContainment() : Switch, Node, LightSource, Group, GeoNode
  • diffuse : NVSGMaterial, NVSGLight
  • diffuseColor : NBFLightSource
  • DirectedLight() : DirectedLight
  • direction : NVSGLight, NBFSpotLight, NBFDirectedLight, NBFCamera
  • disableHWFSAA() : GLWinRenderArea
  • distance() : Vecnf, Quatf, Plane3f
  • doApply() : VertexUnifyTraverser, VertexAttributeSetUnifyTraverser, Traverser, SwitchToGroupTraverser, StateSetUnifyTraverser, SmoothTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, OptimizeTraverser, NormalizeTraverser, LODEliminateTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GLTraverser, GeoNodeUnifyTraverser, DestrippingTraverser, CullTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • DOLLY1 : TrackballTransformManipulator, TrackballCameraManipulator
  • DOLLY2 : TrackballTransformManipulator, TrackballCameraManipulator
  • doneReading() : ISWMRSync
  • doneWriting() : ISWMRSync
  • doRender() : RenderTraverser, GLTraverser
  • Drawable() : Drawable
  • drawables : geometrySet_t
  • dumpIntersectionList() : RayIntersectTraverser

- e -

  • emission : NVSGMaterial
  • emptyCount : EmptyResult
  • enableHWFSAA() : GLWinRenderArea
  • encountered : PlugInCallback::UnexpectedTokenInfo
  • endEdit() : Traverser
  • EndImport() : NVNVB
  • endOcclusionCullQuery() : RenderTraverser, GLTraverser
  • equivalentCount : EquivalenceResult
  • expected : PlugInCallback::UnexpectedTokenInfo
  • expectedVersion : PlugInCallback::IncompatibleFileInfo

- f -

  • F_IMAGE_STREAM : 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
  • FaceAttribute() : FaceAttribute
  • falloffExponent : NBFSpotLight
  • farDist : NBFCamera
  • file : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::FileAccessFailedInfo, texImage_t
  • finishUpload() : TextureImage
  • firstFrame() : AnimationManipulator
  • FixedAllocator() : FixedAllocator
  • flags : texImage_t
  • FlightCameraManipulator() : FlightCameraManipulator
  • FLYBACKWARD : FlightCameraManipulator
  • FLYFORWARD : FlightCameraManipulator
  • focusDist : NBFCamera
  • fogCoords : NBFVertexAttributeSet
  • format() : TraceFunctor, Log
  • FramedAnimation() : FramedAnimation
  • freeMemory() : Chunk
  • frontAmbientColor : NBFMaterial
  • frontDiffuseColor : NBFMaterial
  • frontEmissiveColor : NBFMaterial
  • frontFaceMode : NBFFaceAttribute
  • frontOpacity : NBFMaterial
  • frontSpecularColor : NBFMaterial
  • frontSpecularExponent : NBFMaterial
  • FrustumCullTraverser() : FrustumCullTraverser

- g -

  • GCT_DL : RenderTraverser
  • GCT_NONE : RenderTraverser
  • GCT_VBO : RenderTraverser
  • generateNormals() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • generateTexCoords() : VertexAttributeSet, GeoNode
  • GeometryCacheTechnique : RenderTraverser
  • GeoNode() : GeoNode
  • GeoNodeCombineTraverser() : GeoNodeCombineTraverser
  • GeoNodeUnifyTraverser() : GeoNodeUnifyTraverser
  • get() : RCObject_AutoPtr, Lockable
  • getActive() : Switch
  • getActiveVariant() : StateSet
  • getActiveVariantKey() : StateSet
  • getAlignment() : MapMatrix, MapArray
  • getAmbientColor() : Scene, Material, LightSource
  • getAnalysis() : AnalyzeTraverser
  • getAnimation() : Bone, LightSource, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • getAnimationFrame() : ViewState
  • getAnnotation() : Node
  • 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
  • getBoolAnnotationValue() : CgFxEffect
  • getBoolParameterValue() : CgFxEffect
  • getBoolPassStateValue() : CgFxEffect
  • getBoolSamplerStateValue() : CgFxEffect
  • getBorderColor() : TextureAttributeItem
  • getBoundingSphere() : Node, HighlightObject, Drawable
  • getButtonState() : MouseInput
  • getBytesPerImage() : TextureImage
  • getBytesPerPixel() : TextureImage
  • getBytesPerScanLine() : TextureImage
  • getCamera() : ViewState, Scene
  • getCameraAnimation() : Scene
  • getCenter() : LOD, Trafo, Sphere3f
  • getChild() : Group, CullData
  • getChildPositions() : Group
  • getClipPlane() : Group
  • getClipToModel() : TransformStack
  • getClipToView() : TransformStack
  • getColor() : HighlightEdges, HighlightBox, Bitmap
  • getColors() : VertexAttributeSet
  • getColorsDim() : VertexAttributeSet
  • getContext() : CgFxEffect
  • getCreationFlags() : TextureImage
  • getCullCode() : CullData
  • getCullTraverser() : RenderArea
  • getCullTree() : ViewState
  • getCurrentCgFx() : RenderTraverser
  • getCurrentFrame() : InterpolatedAnimation
  • getCurrentTechnique() : CgFxEffect
  • getCurrentValue() : InterpolatedAnimation
  • getCurrentX() : MouseInput
  • getCurrentY() : MouseInput
  • getCutoffAngle() : SpotLight
  • getData() : 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
  • getDist() : Intersection
  • getDrawable() : Intersection, GeoNode
  • getEffect() : CgFx
  • getEmissiveColor() : Material
  • getEntrySize() : MapMatrix, MapArray
  • getEnvColor() : TextureAttributeItem
  • getEnvMode() : TextureAttributeItem
  • getErrorMessage() : NVSGException
  • getFaceMode() : RenderTraverser
  • getFaces() : Triangles, Quads
  • getFalloffExponent() : SpotLight
  • getFarDistance() : Camera
  • getFieldOfView() : PerspectiveCamera
  • getFileName() : CgFxEffect
  • getFirstItem() : TextureAttribute
  • getFirstVariantIterator() : StateSet
  • getFloatAnnotationValue() : CgFxEffect
  • getFloatParameterValue() : CgFxEffect
  • getFloatPassStateValue() : CgFxEffect
  • getFloatSamplerStateValue() : CgFxEffect
  • getFocusDistance() : Camera
  • getFogCoords() : VertexAttributeSet
  • getFormat() : TextureImage
  • getFragmentProgram() : CgFxEffect
  • getFrame() : InterpolatedAnimation
  • getFromHead() : Path
  • getFromTail() : Path
  • getFrontFaceMode() : FaceAttribute
  • getGeometryCacheTechnique() : RenderTraverser
  • getGeometryIndex() : GeoNode
  • getHead() : Path
  • getHeadLight() : Camera
  • getHeight() : TextureImage, Map
  • getHigherLevelObjectCode() : Object
  • getHighlightObject() : Drawable
  • getHints() : Node
  • getHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • getIgnoreNames() : OptimizeTraverser
  • getIgnoreShares() : PrimitiveSetCombineTraverser
  • getIncarnation() : Object
  • getIndexOfMap() : MapMatrix, MapArray
  • getIndices() : IndependentPrimitiveSet
  • getIntAnnotationValue() : CgFxEffect
  • getIntensity() : LightSource
  • getInterface : PlugInServer
  • getInterleavedFormat() : VertexAttributeSet
  • getIntersections() : RayIntersectTraverser
  • getIntParameterValue() : CgFxEffect
  • getIntPassStateValue() : CgFxEffect
  • getIntSamplerStateValue() : CgFxEffect
  • getInverse() : LightSource, Trafo
  • getInverseProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getIsp() : Intersection
  • getJitters() : ViewState
  • getJitterTechnique() : RenderTraverser
  • getKey() : InterpolatedAnimation
  • getKeyState() : KeyInput
  • getLastRecentlyUsedDeviceAbstractionLinkData() : DALHost
  • getLastVariantIterator() : StateSet
  • getLastX() : MouseInput
  • getLastY() : MouseInput
  • getLength() : Path
  • getLight() : CgFxEffect
  • getLightAmbientValue() : CgFxEffect
  • getLightByName() : CgFxEffect
  • getLightBySemantic() : CgFxEffect
  • getLightConstantAttenuationValue() : CgFxEffect
  • getLightDiffuseValue() : CgFxEffect
  • getLightDirectionValue() : CgFxEffect
  • getLightLinearAttenuationValue() : CgFxEffect
  • getLightPositionValue() : CgFxEffect
  • getLightQuadraticAttenuationValue() : CgFxEffect
  • getLightSpecularValue() : CgFxEffect
  • getLightSpotCutoffValue() : CgFxEffect
  • getLightSpotExponentValue() : CgFxEffect
  • getLineWidth() : RenderTraverser, HighlightEdges, HighlightBox
  • getLODRangeScale() : ViewState
  • getLODToUse() : LOD
  • getLowerLeft() : MapObject
  • getMagFilterMode() : TextureAttributeItem
  • getMap() : MapMatrix, MapElement, MapArray
  • getMapList() : ViewState
  • getMapObject() : MapList
  • getMapPosition() : RenderTraverser
  • getMaterial() : CgFxEffect
  • getMaterialAmbientValue() : CgFxEffect
  • getMaterialDiffuseValue() : CgFxEffect
  • getMaterialEmissionValue() : CgFxEffect
  • getMaterialShininessValue() : CgFxEffect
  • getMaterialSpecularValue() : CgFxEffect
  • getMatrix() : TextureAttributeItem, Bone, Trafo
  • getMaxNumberOfVertices() : PrimitiveSetCombineTraverser
  • getMeshes() : MeshedPrimitiveSet
  • getMinFilterMode() : TextureAttributeItem
  • getMinimalLengths() : StrippingTraverser
  • getMipmapUseCount() : TextureImage
  • getModelToClip() : TransformStack
  • getModelToView() : TransformStack
  • getModelToWorld() : TransformStack
  • getModelToWorldMatrix() : Path
  • getName() : Object
  • getNearDistance() : Camera
  • getNearest() : RayIntersectTraverser
  • getNextItem() : TextureAttribute
  • getNextVariantIterator() : StateSet
  • getNormals() : VertexAttributeSet
  • getNumberOfActive() : Switch
  • getNumberOfActiveClipPlanes() : Group
  • getNumberOfAnnotationValueComponents() : CgFxEffect
  • getNumberOfArrayParameterElements() : CgFxEffect
  • getNumberOfAttributes() : StateVariant, StateSet, StatePass
  • getNumberOfCameraAnimations() : Scene
  • getNumberOfCameras() : Scene
  • getNumberOfChildren() : Group, CullData
  • getNumberOfClipPlanes() : Group
  • getNumberOfColors() : VertexAttributeSet
  • getNumberOfColumns() : MapMatrix
  • getNumberOfCullTraverser() : RenderArea
  • getNumberOfDrawables() : GeoNode
  • getNumberOfFaces() : Triangles, Quads
  • getNumberOfFogCoords() : VertexAttributeSet
  • getNumberOfFrames() : SkinnedTriangles, Scene, Node, LightSource, InterpolatedAnimation, Group, GeoNode, FramedAnimation, Drawable, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • getNumberOfGeometries() : GeoNode
  • getNumberOfHeadLights() : Camera
  • getNumberOfImages() : TextureImage
  • getNumberOfIndices() : IndependentPrimitiveSet
  • getNumberOfIntersections() : RayIntersectTraverser
  • getNumberOfItems() : TextureAttribute
  • getNumberOfJitters() : ViewState
  • getNumberOfKeys() : InterpolatedAnimation
  • getNumberOfLights() : CgFxEffect
  • getNumberOfMapObjects() : MapList
  • getNumberOfMaps() : MapMatrix, MapArray
  • getNumberOfMeshes() : MeshedPrimitiveSet
  • getNumberOfMipmaps() : TextureImage
  • getNumberOfNormals() : VertexAttributeSet
  • getNumberOfOwners() : VertexAttributeSet, TextureAttributeItem, StateVariant, StateSet, StatePass, Drawable
  • getNumberOfParameterAnnotations() : CgFxEffect
  • getNumberOfParameterValueComponents() : CgFxEffect
  • getNumberOfParents() : StateAttribute, Node
  • getNumberOfPassAnnotations() : CgFxEffect
  • getNumberOfPasses() : StateVariant, StateSet, CgFxEffect
  • getNumberOfPassStateValueComponents() : CgFxEffect
  • getNumberOfPrimitiveSets() : Shape
  • getNumberOfProgramParameters() : 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
  • getNumberOfVertexAttributeBytes() : VertexAttributeSet
  • getNumberOfVertexAttributeData() : VertexAttributeSet
  • getNumberOfVertices() : VertexAttributeSet
  • getObjectCode() : Object
  • getOcclusionCullResult() : RenderTraverser, GLTraverser
  • getOITMaxPasses() : RenderTraverser
  • getOITTechnique() : RenderTraverser
  • getOITThreshold() : RenderTraverser
  • getOpacity() : Material
  • getOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • getOwner() : VertexAttributeSet, TextureAttributeItem, StateVariant, StateSet, StatePass, Drawable
  • getParameterAnnotation() : CgFxEffect
  • getParameterAnnotationByName() : CgFxEffect
  • getParameterByName() : CgFxEffect
  • getParameterBySemantic() : CgFxEffect
  • getParameterName() : CgFxEffect
  • getParameterSemantic() : CgFxEffect
  • getParameterTypeString() : CgFxEffect
  • getParameterValueAsFloat() : CgFxEffect
  • getParameterValueSize() : CgFxEffect
  • getParent() : StateAttribute, 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 : ILTexLoader
  • getPlugInterfaceType() : UPIID
  • getPlugSpecificIDString() : UPIID
  • getPointSize() : RenderTraverser
  • getPolygonOffsetFactor() : FaceAttribute
  • getPolygonOffsetUnits() : FaceAttribute
  • getPosition() : SpotLight, PointLight, MapObject, Camera
  • getPrimitiveIndex() : Intersection
  • getPrimitiveSet() : Shape, HighlightEdges
  • getProblems() : RenderArea, Traverser
  • getProgramParameter() : CgFxEffect
  • getProgramProfile() : CgFxEffect
  • getProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getPtr() : Vecnf, Matnnf
  • getRadius() : Sphere3f
  • getRangeLock() : LOD
  • getRanges() : LOD
  • getRelation() : MapObject
  • getRenderTechnique() : RenderTraverser
  • getRenderTraverser() : RenderArea
  • getResults() : SearchTraverser
  • getRootNode() : Scene
  • getRotationAxis() : Billboard
  • getSampler() : CgFxEffect
  • getSamplerByName() : CgFxEffect
  • getSamplerByTextureParameterName() : CgFxEffect
  • getSamplerTexture() : CgFxEffect
  • getSamplerTextureFileName() : CgFxEffect
  • getSamplerTextureImage() : CgFxEffect
  • getScaleOrientation() : Trafo
  • getScaling() : TextureAttributeItem, Trafo
  • getScene() : RenderArea
  • getSecondaryColors() : VertexAttributeSet
  • getSecondaryColorsDim() : VertexAttributeSet
  • getSegments() : Lines
  • getShadowMapIntensity() : RenderTraverser
  • getShadowMapSize() : RenderTraverser
  • getShadowTechnique() : RenderTraverser
  • getSize() : Trackball, PointAttribute, MapObject, MapMatrix, MapElement, MapArray
  • getSkins() : SkinnedTriangles
  • getSortingPolicy() : RenderTraverser
  • getSourceCode() : CgFxEffect
  • getSourceFunction() : BlendAttribute
  • getSpacing() : MapMatrix, MapArray
  • getSpecularColor() : Material, LightSource
  • getSpecularExponent() : Material
  • getSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • getSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • getStackDepth() : TransformStack
  • getStartX() : MouseInput
  • getStartY() : MouseInput
  • getStateSet() : GeoNode
  • getStereoAutomaticEyeDistanceFactor() : ViewState
  • getStereoEyeDistance() : ViewState
  • getStippleFactor() : LineAttribute
  • getStipplePattern() : LineAttribute
  • getStringAnnotationValue() : CgFxEffect
  • getStringParameterValue() : CgFxEffect
  • getStrips() : StrippedPrimitiveSet
  • getStructParameterMember() : CgFxEffect
  • getStructParameterMemberByName() : CgFxEffect
  • getSupportWidth() : Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter
  • getTail() : Path
  • getTargetDistance() : ViewState
  • getTechnique() : CgFxEffect
  • getTechniqueAnnotation() : CgFxEffect
  • getTechniqueAnnotationByName() : CgFxEffect
  • getTechniqueByName() : CgFxEffect
  • getTechniqueName() : CgFxEffect
  • getTexCoords() : VertexAttributeSet
  • getTexCoordsDim() : VertexAttributeSet
  • getTexGenLinearPlane() : TextureAttributeItem
  • getTexGenMode() : TextureAttributeItem
  • getTextureAttributeItem() : TextureAttribute
  • getTextureFileName() : TextureAttributeItem
  • getTextureImage() : TextureAttributeItem
  • getTextureSizeLimit() : RenderTraverser
  • getTrafo() : Transform
  • getTrafoAxisAligned() : Billboard
  • getTrafoScreenAligned() : Billboard
  • getTransform() : 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
  • getUnpackAlignment() : TextureImage
  • getUpVector() : Camera
  • getValue() : InterpolatedAnimation
  • getVariant() : StateSet
  • getVariantKey() : StateSet
  • getVertexAttributeData() : VertexAttributeSet
  • getVertexAttributeDataDim() : VertexAttributeSet
  • getVertexAttributeIndex() : NormalizeTraverser
  • getVertexAttributeSet() : PrimitiveSet
  • getVertexIndices() : Intersection
  • getVertexProgram() : CgFxEffect
  • getVertices() : VertexAttributeSet, HighlightBox
  • getViewportHeight() : RenderArea
  • getViewportWidth() : RenderArea
  • getViewState() : RenderArea
  • getViewToClip() : TransformStack
  • getViewToModel() : TransformStack
  • getViewToWorld() : TransformStack
  • getViewToWorldMatrix() : Camera
  • getVSensitivity() : FlightCameraManipulator
  • getWeight() : Bone
  • getWidth() : TextureImage, Map, LineAttribute
  • getWindowOffset() : Camera
  • getWindowRegion() : Camera
  • getWindowSize() : Camera
  • getWorldToModel() : TransformStack
  • getWorldToView() : TransformStack
  • getWorldToViewMatrix() : Camera
  • getWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • getWrapMode() : TextureAttributeItem
  • GLAccum : GLContext
  • GLActiveTexture : GLContext
  • GLAlphaFunc : GLContext
  • GLAreTexturesResident : GLContext
  • GLArrayElement : GLContext
  • GLBegin : GLContext
  • GLBeginOcclusionQuery : GLContext
  • GLBeginQuery : GLContext
  • GLBindBuffer : GLContext
  • GLBindProgram : GLContext
  • GLBindTexture : GLContext
  • GLBitmap : GLContext
  • GLBlendFunc : GLContext
  • GLBlendFuncSeparate : GLContext
  • GLBufferData : GLContext
  • GLBufferSubData : GLContext
  • GLCallList : GLContext
  • GLCallLists : GLContext
  • GLClear : GLContext
  • GLClearAccum : GLContext
  • GLClearColor : GLContext
  • GLClearDepth : GLContext
  • GLClearIndex : GLContext
  • GLClearStencil : GLContext
  • GLClientActiveTexture : GLContext
  • GLClipPlane : GLContext
  • GLColor3b : GLContext
  • GLColor3bv : GLContext
  • GLColor3d : GLContext
  • GLColor3dv : GLContext
  • GLColor3f : GLContext
  • GLColor3fv : 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
  • GLColor4i : GLContext
  • GLColor4iv : GLContext
  • GLColor4s : GLContext
  • GLColor4sv : GLContext
  • GLColor4ub : GLContext
  • GLColor4ubv : GLContext
  • GLColor4ui : GLContext
  • GLColor4uiv : GLContext
  • GLColor4us : GLContext
  • GLColor4usv : GLContext
  • GLColorMask : GLContext
  • GLColorMaterial : GLContext
  • GLColorPointer : GLContext
  • GLCompressedTexImage1D : GLContext
  • GLCompressedTexImage2D : GLContext
  • GLCompressedTexImage3D : GLContext
  • GLCopyPixels : GLContext
  • GLCopyTexImage1D : GLContext
  • GLCopyTexImage2D : GLContext
  • GLCopyTexSubImage1D : GLContext
  • GLCopyTexSubImage2D : GLContext
  • GLCullFace : GLContext
  • GLDeleteBuffers : GLContext
  • GLDeleteLists : GLContext
  • GLDeleteOcclusionQueries : GLContext
  • GLDeletePrograms : GLContext
  • GLDeleteQueries : GLContext
  • GLDeleteTextures : GLContext
  • GLDepthFunc : GLContext
  • GLDepthMask : GLContext
  • GLDepthRange : GLContext
  • GLDisable : GLContext
  • GLDisableBlend : GLContext
  • GLDisableClientState : GLContext
  • GLDisableColorArray : GLContext
  • GLDisableColorMaterial : GLContext
  • GLDisableCullFace : GLContext
  • GLDisableDepthTest : GLContext
  • GLDisableFogCoordinateArray : GLContext
  • GLDisableLighting : GLContext
  • GLDisableLineSmooth : GLContext
  • GLDisableLineStipple : GLContext
  • GLDisableNormalArray : GLContext
  • GLDisableNormalize : GLContext
  • GLDisablePointSmooth : GLContext
  • GLDisablePolygonOffsetFill : GLContext
  • GLDisablePolygonOffsetLine : GLContext
  • GLDisablePolygonOffsetPoint : GLContext
  • GLDisablePolygonStipple : GLContext
  • GLDisableSecondaryColorArray : GLContext
  • GLDisableTexture : GLContext
  • GLDisableTextureCoordArray : GLContext
  • GLDisableTextureGen : GLContext
  • GLDisableVertexArray : GLContext
  • GLDrawArrays : GLContext
  • GLDrawBuffer : GLContext
  • GLDrawElements : GLContext
  • GLDrawPixels : GLContext
  • GLDrawRangeElements : GLContext
  • GLEdgeFlag : GLContext
  • GLEdgeFlagPointer : GLContext
  • GLEdgeFlagv : GLContext
  • GLEnable : GLContext
  • GLEnableBlend : GLContext
  • GLEnableClientState : GLContext
  • GLEnableColorArray : GLContext
  • GLEnableColorMaterial : GLContext
  • GLEnableCullFace : GLContext
  • GLEnableDepthTest : GLContext
  • GLEnableFogCoordinateArray : GLContext
  • GLEnableLighting : GLContext
  • GLEnableLineSmooth : GLContext
  • GLEnableLineStipple : GLContext
  • GLEnableNormalArray : GLContext
  • GLEnableNormalize : GLContext
  • GLEnablePointSmooth : GLContext
  • GLEnablePolygonOffsetFill : GLContext
  • GLEnablePolygonOffsetLine : GLContext
  • GLEnablePolygonOffsetPoint : GLContext
  • GLEnablePolygonStipple : GLContext
  • GLEnableSecondaryColorArray : GLContext
  • GLEnableTexture : GLContext
  • GLEnableTextureCoordArray : GLContext
  • GLEnableTextureGen : GLContext
  • GLEnableVertexArray : GLContext
  • GLEnd : GLContext
  • GLEndList : GLContext
  • GLEndOcclusionQuery : GLContext
  • GLEndQuery : GLContext
  • GLEvalCoord1d : GLContext
  • GLEvalCoord1f : GLContext
  • GLEvalCoord2d : GLContext
  • GLEvalCoord2f : GLContext
  • GLEvalMesh1 : GLContext
  • GLEvalMesh2 : GLContext
  • GLEvalPoint1 : GLContext
  • GLEvalPoint2 : GLContext
  • GLFeedbackBuffer : GLContext
  • GLFinish : GLContext
  • GLFlush : GLContext
  • GLFogCoordPointer : GLContext
  • GLFogf : GLContext
  • GLFogfv : GLContext
  • GLFogi : GLContext
  • GLFogiv : GLContext
  • GLFrontFace : GLContext
  • GLFrustum : GLContext
  • GLFunctions() : GLFunctions
  • GLGenBuffers : GLContext
  • GLGenLists : GLContext
  • GLGenOcclusionQueries : GLContext
  • GLGenPrograms : GLContext
  • GLGenQueries : GLContext
  • GLGenTextures : GLContext
  • GLGetBooleanv : GLContext
  • GLGetClipPlane : GLContext
  • GLGetDoublev : GLContext
  • GLGetFloatv : GLContext
  • GLGetIntegerv : GLContext
  • GLGetLightfv : GLContext
  • GLGetLightiv : GLContext
  • GLGetMapdv : GLContext
  • GLGetMapfv : GLContext
  • GLGetMapiv : GLContext
  • GLGetMaterialfv : GLContext
  • GLGetMaterialiv : GLContext
  • GLGetMaxTexCoords : GLContext
  • GLGetMaxTexImageUnits : GLContext
  • GLGetMaxTexUnits : GLContext
  • GLGetOcclusionQueryuiv : GLContext
  • GLGetPixelMapfv : GLContext
  • GLGetPixelMapuiv : GLContext
  • GLGetPixelMapusv : GLContext
  • GLGetPointerv : GLContext
  • GLGetPolygonStipple : GLContext
  • GLGetQueryiv : GLContext
  • GLGetQueryObjectiv : GLContext
  • GLGetQueryObjectuiv : GLContext
  • GLGetString : GLContext
  • GLGetTexEnvfv : GLContext
  • GLGetTexEnviv : GLContext
  • GLGetTexGendv : GLContext
  • GLGetTexGenfv : GLContext
  • GLGetTexGeniv : GLContext
  • GLGetTexImage : GLContext
  • GLGetTexLevelParameterfv : GLContext
  • GLGetTexLevelParameteriv : GLContext
  • GLGetTexParameterfv : GLContext
  • GLGetTexParameteriv : GLContext
  • GLHint : GLContext
  • GLIndexd : GLContext
  • GLIndexf : GLContext
  • GLIndexi : GLContext
  • GLIndexMask : GLContext
  • GLIndexPointer : GLContext
  • GLIndexs : GLContext
  • GLIndexub : GLContext
  • GLInitNames : GLContext
  • GLInterleavedArrays : GLContext
  • GLIsBuffer : GLContext
  • GLIsEnabled : GLContext
  • GLIsExtensionAvailable : GLContext
  • GLIsExtensionExported : GLContext
  • GLIsList : GLContext
  • GLIsOcclusionQuery : GLContext
  • GLIsProgram : GLContext
  • GLIsQuery : 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
  • GLLightQuadraticAttenuation : GLContext
  • GLLightSpecular : GLContext
  • GLLightSpotCutoff : GLContext
  • GLLightSpotDirection : GLContext
  • GLLightSpotExponent : GLContext
  • GLLineStipple : GLContext
  • GLLineWidth : GLContext
  • GLListBase : GLContext
  • GLLoadIdentity : GLContext
  • GLLoadMatrixd : GLContext
  • GLLoadMatrixf : GLContext
  • GLLoadName : GLContext
  • GLLoadProgram : GLContext
  • GLLoadTransposedMatrixd : GLContext
  • GLLoadTransposeMatrixf : 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
  • GLMFCRAWnd() : GLMFCRAWnd
  • GLMultiDrawElements : GLContext
  • GLMultiTexCoord2f : GLContext
  • GLMultMatrixd : GLContext
  • GLMultMatrixf : GLContext
  • GLMultTransposeMatrixd : GLContext
  • GLMultTransposeMatrixf : GLContext
  • GLNewList : GLContext
  • GLNormal3b : GLContext
  • GLNormal3bv : GLContext
  • GLNormal3d : GLContext
  • GLNormal3dv : GLContext
  • GLNormal3f : GLContext
  • GLNormal3fv : GLContext
  • GLNormal3i : GLContext
  • GLNormal3iv : GLContext
  • GLNormal3s : GLContext
  • GLNormal3sv : GLContext
  • GLNormalPointer : GLContext
  • GLObjects() : GLObjects
  • GLOrtho : GLContext
  • GLPassThrough : GLContext
  • GLPixelMapfv : GLContext
  • GLPixelMapuiv : GLContext
  • GLPixelMapusv : GLContext
  • GLPixelStoref : GLContext
  • GLPixelStorei : GLContext
  • GLPixelTransferf : GLContext
  • GLPixelTransferi : GLContext
  • GLPixelZoom : GLContext
  • GLPointSize : GLContext
  • GLPolygonMode : GLContext
  • GLPolygonModeBack : GLContext
  • GLPolygonModeFront : GLContext
  • GLPolygonModeFrontAndBack : GLContext
  • GLPolygonOffset : GLContext
  • GLPolygonStipple : GLContext
  • GLPopAttrib : GLContext
  • GLPopClientAttrib : GLContext
  • GLPopMatrix : GLContext
  • GLPopName : GLContext
  • GLPrimitiveRestartIndex : GLContext
  • GLPrioritizeTextures : GLContext
  • GLProgramNamedParameter4f : 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
  • GLRenderMode : GLContext
  • GLRotated : GLContext
  • GLRotatef : GLContext
  • GLScaled : GLContext
  • GLScalef : GLContext
  • GLScissor : GLContext
  • GLSecondaryColorPointer : GLContext
  • GLSelectBuffer : GLContext
  • GLSetWindowStereoMode : GLContext
  • GLShadeModel : GLContext
  • GLStencilFunc : GLContext
  • GLStencilMask : GLContext
  • GLStencilOp : GLContext
  • GLTexCoord1d : GLContext
  • GLTexCoord1f : GLContext
  • GLTexCoord1i : GLContext
  • GLTexCoord1s : GLContext
  • GLTexCoord2d : GLContext
  • GLTexCoord2f : GLContext
  • GLTexCoord2fv : GLContext
  • GLTexCoord2i : GLContext
  • GLTexCoord2s : GLContext
  • GLTexCoord3d : GLContext
  • GLTexCoord3f : GLContext
  • GLTexCoord3i : GLContext
  • GLTexCoord3s : GLContext
  • GLTexCoord4d : GLContext
  • GLTexCoord4f : GLContext
  • GLTexCoord4i : GLContext
  • GLTexCoord4s : 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
  • GLTexParameteriv : GLContext
  • GLTexSubImage1D : GLContext
  • GLTexSubImage2D : GLContext
  • GLTextureBorderColor : GLContext
  • GLTextureEnvColor : GLContext
  • GLTextureEnvMode : GLContext
  • GLTextureMagFilter : GLContext
  • GLTextureMinFilter : GLContext
  • GLTextureWrapR : GLContext
  • GLTextureWrapS : GLContext
  • GLTextureWrapT : GLContext
  • GLTranslated : GLContext
  • GLTranslatef : GLContext
  • GLTraverser() : GLTraverser
  • GLUnmapBuffer : GLContext
  • GLVertex2d : GLContext
  • GLVertex2f : GLContext
  • GLVertex2i : GLContext
  • GLVertex2s : GLContext
  • GLVertex3d : GLContext
  • GLVertex3f : GLContext
  • GLVertex3fv : GLContext
  • GLVertex3i : GLContext
  • GLVertex3s : GLContext
  • GLVertex4d : GLContext
  • GLVertex4f : GLContext
  • GLVertex4i : GLContext
  • GLVertex4s : GLContext
  • GLVertexPointer : GLContext
  • GLViewport : GLContext
  • GLWinRenderArea() : GLWinRenderArea
  • GLXCreateContext : GLContext
  • GLXDestroyContext : GLContext
  • GLXGetCurrentContext : GLContext
  • GLXGetCurrentDrawable : GLContext
  • gotoFrame() : AnimationManipulator
  • Group() : Group
  • GroupEliminateTraverser() : GroupEliminateTraverser

- h -

  • handleAnimatedQuads() : VertexUnifyTraverser, TriangulateTraverser, Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleAnimatedTransform() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleAnimatedTriangles() : VertexUnifyTraverser, Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleBillboard() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleBitmap() : Traverser, GLTraverser
  • handleBlendAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleCgFx() : Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleDepthAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleDirectedLight() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFaceAttribute() : Traverser, SearchTraverser, RayIntersectTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedTrafoAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedVNVectorAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleGeoNode() : TriangulateTraverser, Traverser, StrippingTraverser, StateSetUnifyTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, DestrippingTraverser, CullTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleGroup() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RayIntersectTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleHighlightBox() : Traverser, AppTraverser
  • handleHighlightEdges() : Traverser
  • handleLinearInterpolatedTrafoAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLinearInterpolatedVNVectorAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLines() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineStrips() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLOD() : Traverser, SwitchToGroupTraverser, SearchTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleMapArray() : Traverser, RenderTraverser
  • handleMapElement() : Traverser, RenderTraverser
  • handleMapList() : Traverser, GLTraverser
  • handleMapMatrix() : Traverser, RenderTraverser
  • handleMaterial() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleParallelCamera() : Traverser, SearchTraverser, RenderTraverser, ModelViewTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePerspectiveCamera() : Traverser, SearchTraverser, RenderTraverser, ModelViewTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointLight() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePoints() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadMeshes() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuads() : TriangulateTraverser, Traverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadStrips() : TriangulateTraverser, Traverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleShape() : Traverser, AnalyzeTraverser
  • handleSkinnedTriangles() : VertexUnifyTraverser, Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSpotLight() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStatePass() : Traverser, StateSetUnifyTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStateSet() : Traverser, StateSetUnifyTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetCombineTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleStateVariant() : Traverser, StateSetUnifyTraverser, SearchTraverser, RenderTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSwitch() : Traverser, SearchTraverser, RayIntersectTraverser, LODEliminateTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTextureAttribute() : Traverser, StateSetUnifyTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTextureAttributeItem() : Traverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTransform() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleTriangles() : Traverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTriFans() : Traverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTriStrips() : Traverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleVertexAttributeSet() : VertexUnifyTraverser, Traverser, NormalizeTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • hasChild() : Group
  • hasFaces() : Triangles, Quads
  • hasIndices() : IndependentPrimitiveSet
  • hasMeshes() : MeshedPrimitiveSet
  • hasSegments() : Lines
  • hasStrips() : StrippedPrimitiveSet
  • hasTexCoords() : VertexAttributeSet
  • headLights : NBFCamera
  • height : texImage_t, meshSet_t
  • hiddenBegin() : RenderTraverser, GLTraverser
  • hiddenEnd() : RenderTraverser, GLTraverser
  • highlightBegin() : RenderTraverser, GLTraverser
  • HighlightBox() : HighlightBox
  • HighlightEdges() : HighlightEdges
  • highlightEnd() : RenderTraverser, GLTraverser
  • HighlightObject() : HighlightObject
  • hourLastModified : NBFHeader

- i -

  • IAllocator() : IAllocator
  • identityCount : IdentityResult
  • IdentityToGroupTraverser() : IdentityToGroupTraverser
  • IMG_BGR : TextureImage
  • IMG_BGRA : TextureImage
  • IMG_BYTE : TextureImage
  • IMG_COLOR_INDEX : TextureImage
  • IMG_FLOAT : TextureImage
  • IMG_HALF : TextureImage
  • IMG_INT : TextureImage
  • IMG_LUMINANCE : TextureImage
  • IMG_LUMINANCE_ALPHA : TextureImage
  • IMG_RGB : TextureImage
  • IMG_RGBA : TextureImage
  • IMG_SHORT : TextureImage
  • IMG_UNKNOWN_FORMAT : TextureImage
  • IMG_UNKNOWN_TYPE : TextureImage
  • IMG_UNSIGNED_BYTE : TextureImage
  • IMG_UNSIGNED_INT : TextureImage
  • IMG_UNSIGNED_SHORT : TextureImage
  • Incarnation() : Incarnation
  • increaseIncarnation() : Object
  • INCREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • incrementMipmapUseCount() : TextureImage
  • IndependentPrimitiveSet() : IndependentPrimitiveSet
  • indices : NBFIndependentPrimitiveSet, meshSet_t, indexSet_t
  • init() : GLMFCRAWnd, Log, FixedAllocator, RenderArea, GLWinRenderArea
  • initGL() : GLWinRenderArea
  • insertEmptyColumn() : MapMatrix
  • insertMap() : MapMatrix, MapArray
  • insertMapObject() : MapList
  • instance() : Singleton
  • intensity : NBFLightSource
  • InterpolatedAnimation() : InterpolatedAnimation
  • interruptRender() : RenderArea
  • interruptTraversal() : Traverser
  • intersectingSphere() : Sphere3f
  • Intersection() : Intersection
  • intersectLine() : RayIntersectTraverser
  • intersectPoint() : RayIntersectTraverser
  • intersectTriangle() : RayIntersectTraverser
  • invalidate() : Sphere3f, HighlightObject
  • invalidateBoundingSphere() : Node, HighlightObject, Drawable
  • invalidateCaches() : Group, GeoNode
  • invalidateCgFxContainment() : StateVariant, StateSet, StatePass, Node, Group, GeoNode
  • invalidateHintsContainment() : Node
  • invalidateIncarnation() : VertexAttributeSet, TextureAttributeItem, StateVariant, StateSet, StatePass, StateAttribute, Object, Node, Drawable
  • invalidateLightContainment() : Node, Group
  • invalidateNumberOfFrames() : Node, Group, GeoNode, Drawable
  • invalidateTransparencyContainment() : StateVariant, StateSet, StatePass, StateAttribute, Node
  • invert() : Matnnf
  • is1D() : TextureImage
  • is2D() : TextureImage
  • is3D() : TextureImage
  • isActive() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator, 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
  • isCgFxAware() : RenderTraverser
  • isClipPlaneActive() : Group
  • isCompatible() : PrimitiveSet
  • isCritical() : NVSGException
  • isCubeMap() : TextureImage
  • isDataShared() : VertexAttributeSet, TextureAttributeItem, StrippedPrimitiveSet, SkinnedTriangles, Object, MeshedPrimitiveSet, Material, IndependentPrimitiveSet, CgFx
  • isDepthTestingEnabled() : DepthAttribute
  • isDepthWritingEnabled() : DepthAttribute
  • isDolly() : TrackballTransformManipulator, TrackballCameraManipulator
  • isEachPassTransparent() : StateVariant
  • isEmpty() : Sphere3f, Path
  • isEnabled() : Log
  • isEquivalent() : VertexAttributeSet, Transform, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, Shape, PrimitiveSet, PointLight, PointAttribute, Object, MeshedPrimitiveSet, Material, LOD, LineAttribute, LightSource, InterpolatedAnimation, IndependentPrimitiveSet, Group, GeoNode, FramedAnimation, FaceAttribute, DepthAttribute, CgFx, BlendAttribute, Billboard, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • isExported() : GLFunctions
  • isFaceCullingOverwrite() : RenderTraverser
  • isFaceModeOverwrite() : RenderTraverser
  • isFloatAnnotation() : CgFxEffect
  • isFloatingPoint() : TextureImage
  • isFloatParameter() : CgFxEffect
  • isFloatPassState() : CgFxEffect
  • isFloatSamplerState() : CgFxEffect
  • isFly() : FlightCameraManipulator
  • isFromFile() : CgFxEffect
  • isFromLump() : CgFxEffect
  • isFrontFaceCulling() : RenderTraverser, FaceAttribute
  • isGeometryCacheTechniqueSupported() : RenderTraverser, GLTraverser
  • isHWFSAAAvailable() : RenderArea
  • isHWFSAAEnabled() : GLWinRenderArea
  • isIdentity() : Matnnf
  • isImageStream() : TextureImage
  • isInputProgramParameter() : CgFxEffect
  • isInsideBounds() : Chunk
  • isIntAnnotation() : CgFxEffect
  • isIntParameter() : CgFxEffect
  • isIntPassState() : CgFxEffect
  • isIntSamplerState() : CgFxEffect
  • isJitter : ViewState, NBFViewState
  • isJitterTechniqueSupported() : RenderTraverser, GLTraverser
  • isLightArrayParameter() : CgFxEffect
  • isLightParameter() : CgFxEffect
  • isLineAntiAliasingEnabled() : RenderTraverser
  • isLoadable() : TextureAttributeItem
  • isLocalViewerEnabled() : GLTraverser
  • isMaterialParameter() : CgFxEffect
  • isMatrix22Parameter() : CgFxEffect
  • isMatrix23Parameter() : CgFxEffect
  • isMatrix24Parameter() : CgFxEffect
  • isMatrix32Parameter() : CgFxEffect
  • isMatrix33Parameter() : CgFxEffect
  • isMatrix34Parameter() : CgFxEffect
  • isMatrix42Parameter() : CgFxEffect
  • isMatrix43Parameter() : CgFxEffect
  • isMatrix44Parameter() : CgFxEffect
  • isMipmapSamplerState() : CgFxEffect
  • isNormalized() : Vecnf, Quatf, Matnnf
  • isNull() : Vecnf, Quatf, Matnnf
  • isOcclusionCulling() : RenderTraverser
  • isOcclusionCullingSupported() : RenderTraverser, GLTraverser
  • isOITTechniqueSupported() : RenderTraverser, GLTraverser
  • isOrbit() : TrackballCameraManipulator
  • isOrthogonal() : Matnnf
  • isOutputProgramParameter() : CgFxEffect
  • isOverlayPass() : RenderTraverser
  • isPan() : TrackballTransformManipulator, TrackballCameraManipulator
  • isPointAntiAliasingEnabled() : RenderTraverser
  • isPolygonOffset() : FaceAttribute
  • isProgramCompiled() : CgFxEffect
  • isRangeLockEnabled() : LOD
  • isRenderTechniqueSupported() : RenderTraverser, GLTraverser
  • isRotate() : TrackballTransformManipulator
  • isRotation() : Mat33f
  • isSampler1DParameter() : CgFxEffect
  • isSampler2DParameter() : CgFxEffect
  • isSampler3DParameter() : CgFxEffect
  • isSamplerCubeParameter() : CgFxEffect
  • isSamplerParameter() : CgFxEffect
  • isSamplerRectParameter() : CgFxEffect
  • isScalarParameter() : CgFxEffect
  • isScreenAligned() : Billboard
  • isSeparateSpecularColorEnabled() : GLTraverser
  • isShadowCasting() : LightSource
  • isShadowTechniqueSupported() : RenderTraverser, GLTraverser
  • isShareable() : RCObject
  • isShared : PointerReference, RCObject, NBFObject
  • isStereo : ViewState, NBFViewState
  • isStereoAutomatic : NBFViewState
  • isStereoAutomaticEyeDistanceAdjustment() : ViewState
  • isStereoAvailable() : RenderArea
  • isStereoReversedEyes() : ViewState
  • isStringAnnotation() : CgFxEffect
  • isStringParameter() : CgFxEffect
  • isStructParameter() : CgFxEffect
  • isTilt() : WalkCameraManipulator
  • isTransformParameter() : CgFxEffect
  • isTranslate() : WalkCameraManipulator
  • isTransparencyTechniqueSupported() : RenderTraverser, GLTraverser
  • isTransparent() : StateVariant, StateSet, StatePass, StateAttribute, CgFx, BlendAttribute
  • isTransparentPass() : RenderTraverser, CgFxEffect
  • isTwoSidedLighting() : FaceAttribute
  • isTwoSidedLightingOverwrite() : RenderTraverser
  • isTwoSidedLigthing() : RenderTraverser
  • ISType : RayIntersectTraverser
  • isUnused() : Chunk
  • isUploadDemanded() : TextureImage
  • isValid() : HighlightObject, CgFxEffect
  • isVector2Parameter() : CgFxEffect
  • isVector3Parameter() : CgFxEffect
  • isVector4Parameter() : CgFxEffect
  • isWalk() : WalkCameraManipulator
  • iterator : SearchTraverser

- j -

  • jitters : NBFViewState
  • JitterTechnique : RenderTraverser
  • JT_ACCUM : RenderTraverser
  • JT_NONE : RenderTraverser
  • JT_PBUFFER : RenderTraverser
  • JT_READ_PIXELS : RenderTraverser

- k -

  • key : keyVariant_t
  • keyDown() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator
  • KeyInput() : KeyInput
  • keys : NBFInterpolatedAnimation
  • keyStateVariantPairs : NBFStateSet
  • keyUp() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator

- l -

  • lastFrame() : AnimationManipulator
  • length() : Vecnf
  • lengthd() : Vecnf
  • lengthSquared() : Vecnf
  • lerp() : Trafo, Quatf
  • LightSource() : LightSource
  • linearAttenuation : NVSGLight
  • LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • LineAttribute() : LineAttribute
  • Lines() : Lines
  • LineStrips() : LineStrips
  • load() : TextureLoader, SceneLoader, WRLLoader, NVSGLoader, NVNVB, NVBLoader, NBFLoader, ILTexLoader
  • loadCustomObject() : NBFLoader
  • Lockable() : Lockable
  • LOD() : LOD
  • LODCombineTraverser() : LODCombineTraverser
  • LODEliminateTraverser() : LODEliminateTraverser
  • Log() : Log

- m -

  • m_animationFrame : AppTraverser
  • m_appTraverser : RenderArea
  • m_bApplyingCgFx : AppTraverser
  • m_bones : Skin
  • m_buttonState : MouseInput
  • m_cameraAnimation : AnimationManipulator
  • m_cullStack : Traverser
  • m_cullTraverser : RenderArea
  • m_currentFrame : AnimationManipulator
  • m_currentX : MouseInput
  • m_currentY : MouseInput
  • m_dist : Intersection
  • m_features : RenderArea
  • m_hdc : GLWinRenderArea
  • m_hglrc : GLWinRenderArea
  • m_hSensitivity : WalkCameraManipulator, FlightCameraManipulator
  • m_idRenderArea : RenderArea
  • m_indices : Face
  • m_interrupt : Traverser
  • m_interrupted : Traverser
  • m_isCritical : ProblemInfo
  • m_isp : Intersection
  • m_keyInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_keyState : KeyInput
  • m_lastX : MouseInput
  • m_lastY : MouseInput
  • m_lodStack : Traverser
  • m_missingFeatures : ProblemInfo
  • m_mouseInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_normal : Skin
  • m_nullStateSet : Traverser
  • m_numberOfFrames : AnimationManipulator
  • m_numMSBuffers : RenderArea
  • m_objectCode : Object
  • m_pDrawable : Intersection
  • m_pPath : Intersection
  • m_primitiveIndex : Intersection
  • m_problem : ProblemInfo
  • m_problemLog : RenderArea, Traverser
  • m_raCreated : RenderArea
  • m_raHeight : RenderArea
  • m_raWidth : RenderArea
  • m_renderArea : Manipulator
  • m_renderTraverser : RenderArea
  • m_scene : RenderArea
  • m_ScreenSizeX : WalkCameraManipulator, FlightCameraManipulator
  • m_ScreenSizeY : WalkCameraManipulator, FlightCameraManipulator
  • m_speed : WalkCameraManipulator, FlightCameraManipulator
  • m_speedIncreaseFactor : WalkCameraManipulator, FlightCameraManipulator
  • m_startX : MouseInput
  • m_startY : MouseInput
  • m_tbsize : Trackball
  • m_trafo : LightSource
  • m_transformPath : TransformManipulator
  • m_transformStack : ModelViewTraverser
  • m_traverser : NBFSaver
  • m_vertex : Skin
  • m_vertexIndices : Intersection
  • m_viewState : RenderArea, Traverser
  • m_vSensitivity : FlightCameraManipulator
  • m_worldUpVector : WalkCameraManipulator, FlightCameraManipulator
  • magFilter : NBFTextureAttributeItem
  • magnitude() : Quatf
  • makeCurrent() : GLWinRenderArea
  • Manipulator() : Manipulator
  • Map() : Map
  • MapArray() : MapArray
  • MapElement() : MapElement
  • MapList() : MapList
  • MapMatrix() : MapMatrix
  • MapObject() : MapObject
  • mapOffset() : NBFLoader
  • mapViewOfFile() : NBFSaveTraverser
  • markUnshareable() : RCObject
  • Mat33f() : Mat33f
  • Mat44f() : Mat44f
  • Material() : Material
  • Matnnf() : Matnnf
  • maxElement() : Vecnf
  • MemFunTbl() : MemFunTbl
  • MeshedPrimitiveSet() : MeshedPrimitiveSet
  • meshes : NBFMeshedPrimitiveSet
  • minElement() : Vecnf
  • minFilter : NBFTextureAttributeItem
  • minuteLastModified : NBFHeader
  • mirrorX() : TextureImage
  • mirrorY() : TextureImage
  • missingCount : MissingResult
  • ModelViewTraverser() : ModelViewTraverser
  • 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 -

  • n() : Plane3f
  • name : sampler_t, tweak_t
  • nbfBugfixLevel : NBFHeader
  • nbfMajorVersion : NBFHeader
  • nbfMinorVersion : NBFHeader
  • NBFSaver() : NBFSaver
  • NBFSaveTraverser() : NBFSaveTraverser
  • nearDist : NBFCamera
  • nearestPoint() : Plane3f
  • 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
  • normal : plane_t, skin_t
  • normalize() : Vec3f, Vecnf, Quatf
  • NormalizeTraverser() : NormalizeTraverser
  • normals : VNVector, NBFVertexAttributeSet
  • normalSets : NBFVNVectorAnimation
  • nullNormalsCount : NullNormalsResult
  • nullNormalsNumber : NullNormalsResult
  • numActiveChildren : NBFSwitch
  • numberOfAnimationFrames : NBFScene
  • numBindings : NBFTextureAttribute
  • numBones : skin_t
  • numCameraAnimations : NBFScene
  • numCameras : NBFScene
  • numChars : str_t
  • numChildren : NBFGroup
  • numClipPlanes : NBFGroup
  • numColors : NBFVertexAttributeSet
  • numDrawables : geometrySet_t
  • numFogCoords : NBFVertexAttributeSet
  • numFrames : NBFFramedAnimation
  • numHeadLights : NBFCamera
  • numIndices : NBFIndependentPrimitiveSet, indexSet_t
  • numJitters : NBFViewState
  • numKeys : NBFInterpolatedAnimation
  • numMeshes : NBFMeshedPrimitiveSet
  • numNormals : NBFVertexAttributeSet, NBFVNVectorAnimation
  • numRanges : NBFLOD
  • numSamplers : NBFCgFx
  • numSecondaryColors : NBFVertexAttributeSet
  • numSkins : NBFSkinnedTriangles
  • numStateAttribs : NBFStatePass
  • numStatePasses : NBFStateVariant
  • numStateVariants : NBFStateSet
  • numStrips : NBFStrippedPrimitiveSet
  • numTexCoords : texCoordSet_t
  • numTexCoordsSets : NBFVertexAttributeSet
  • numTweaks : NBFCgFx
  • numVertices : NBFVertexAttributeSet, NBFVNVectorAnimation
  • NVBImportError() : NVNVB
  • NVBLoadTraverser() : NVBLoadTraverser
  • NVBLog() : NVNVB
  • nvsgBugfixLevel : NBFHeader
  • NVSGException() : NVSGException
  • nvsgMajorVersion : NBFHeader
  • nvsgMinorVersion : NBFHeader
  • NVSGSaveTraverser() : NVSGSaveTraverser

- o -

  • Object() : Object
  • objectCode : AnalyzeResult, NBFObject, NBFViewState
  • objectCount : AnalyzeResult
  • objectDataID : NBFObject
  • objectName : NBFObject
  • offset : plane_t
  • Offset_AutoPtr() : Offset_AutoPtr
  • OITTechnique : RenderTraverser
  • onEmptyToken() : PlugInCallback
  • OnEraseBkgnd() : GLMFCRAWnd
  • onError() : PlugInCallback
  • onFileAccessFailed() : PlugInCallback
  • onFileEmpty() : PlugInCallback
  • onFileMappingFailed() : PlugInCallback
  • onFileNotFound() : PlugInCallback
  • onFilesNotFound() : PlugInCallback
  • onImcompatibleFile() : PlugInCallback
  • onIncompatibleValues() : PlugInCallback
  • onInvalidFile() : PlugInCallback
  • onInvalidValue() : PlugInCallback
  • OnPaint() : GLMFCRAWnd
  • onReleaseDAL() : DALDataCreator
  • onUndefinedToken() : PlugInCallback
  • onUnexpectedEndOfFile() : PlugInCallback
  • onUnexpectedToken() : PlugInCallback
  • onUnknownToken() : PlugInCallback
  • onUnsupportedToken() : PlugInCallback
  • onWarning() : PlugInCallback
  • operator *() : Vecnf, Vec4f, Vec3f, Vec2f, Matnnf, Mat44f, PointerReference, RCObject_AutoPtr, RCIPtr, RCPtr, Lockable, Vecnf, Quatf, Matnnf, Offset_AutoPtr
  • operator *=() : Vecnf, Quatf, Matnnf
  • operator const T &() : RegVal
  • operator const T *() : Offset_AutoPtr
  • operator delete() : IAllocator
  • operator new() : IAllocator
  • operator T *() : PointerReference, Offset_AutoPtr
  • operator!=() : CullData, PointerReference, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VariantIterator, Vecnf, Sphere3f, Quatf, Plane3f, Matnnf
  • operator()() : TraceFunctor, traceFileConsoleOutput, traceFileDebugOutput, traceFileOutput, traceConsoleDebugOutput, traceConsoleOutput, traceDebugOutput, removeReference, addReference, Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter, Bone, Sphere3f, Plane3f
  • operator+() : Incarnation, Vecnf, Matnnf
  • operator++() : Incarnation
  • operator+=() : Vecnf, Matnnf
  • operator-() : Vecnf, Vec3f, Quatf, Plane3f, Matnnf
  • operator-=() : Vecnf, Matnnf
  • operator->() : PointerReference, RCObject_AutoPtr, RCIPtr, RCPtr, Lockable, Offset_AutoPtr
  • operator/() : Vecnf, Quatf, Matnnf
  • operator/=() : Vecnf, Quatf, Matnnf
  • operator< : UPIID, UPITID
  • operator=() : RegVal, RCObject_AutoPtr, RCIPtr, RCPtr, RCObject, UPIID, MouseInput, KeyInput, Intersection, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Bone, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, PrimitiveAttribute, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Object, Node, MeshedPrimitiveSet, Material, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, InterpolatedAnimation, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Billboard, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads, Vecnf, Vec3f, Trafo, Sphere3f, Quatf, Plane3f, Matnnf
  • operator==() : CullData, PointerReference, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VNVector, VariantIterator, Bone, Vecnf, Trafo, Sphere3f, Quatf, Plane3f, Matnnf
  • operator[]() : MemFunTbl, LinearInterpolatedAnimation, FramedAnimation, Face, Animation, Vecnf, Quatf, Matnnf
  • operator^() : Vec3f
  • operator~() : Quatf, Matnnf
  • OptimizeTraverser() : OptimizeTraverser
  • ORBIT : TrackballCameraManipulator
  • orbit() : Camera
  • orbitX() : Camera
  • orbitY() : Camera
  • orbitZ() : Camera
  • orientation : trafo_t
  • orthogonalize() : Vecnf
  • orthonormalize() : Vecnf
  • OT_PBUFFER : RenderTraverser
  • OT_TEXTURE : RenderTraverser
  • overlayBegin() : RenderTraverser, GLTraverser
  • overlayEnd() : RenderTraverser, GLTraverser

- p -

  • PADDING() : NBFPointAttribute, NBFLineAttribute, NBFFaceAttribute, NBFDepthAttribute, NBFCgFx, NBFBlendAttribute, NBFStateSet, NBFSpotLight, NBFDirectedLight, NBFLightSource, NBFAnimatedTransform, NBFTransform, NBFBillboard, NBFLOD, NBFNode, NBFAnimatedIndependents, NBFPrimitiveSet, NBFCamera, NBFFramedVNVectorAnimation, NBFFramedTrafoAnimation, NBFTrafoAnimation, NBFObject, NBFViewState, NBFHeader
  • PAN1 : TrackballTransformManipulator, TrackballCameraManipulator
  • PAN2 : TrackballTransformManipulator, TrackballCameraManipulator
  • ParallelCamera() : ParallelCamera
  • Path() : Path
  • PerspectiveCamera() : PerspectiveCamera
  • PIC_ERROR : PlugInCallback
  • PIC_TYPE_ID : PlugInCallback
  • PIC_WARNING : PlugInCallback
  • pickCameraTargetPoint() : RenderArea
  • pickMap() : MapObject, MapMatrix, MapList, MapElement, MapArray
  • PixelDataType : TextureImage
  • PixelFormat : TextureImage
  • pixelFormat : texImage_t
  • pixels : texImage_t
  • Plane3f() : Plane3f
  • PlugInCallback() : PlugInCallback
  • PointAttribute() : PointAttribute
  • PointerReference() : PointerReference
  • PointLight() : PointLight
  • Points() : Points
  • polygonOffsetEnabled : NBFFaceAttribute
  • polygonOffsetFactor : NBFFaceAttribute
  • polygonOffsetUnits : NBFFaceAttribute
  • pop() : Path
  • popCullTraverser() : RenderArea
  • popModelToWorld() : TransformStack
  • position : NVSGLight, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UnexpectedTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo, NBFSpotLight, NBFPointLight, NBFCamera
  • postAddChild() : Switch, Group
  • postApply() : Traverser
  • postRemoveChild() : Switch, Group
  • postTraverseDrawable() : Traverser
  • postTraverseDrawables() : Traverser, RenderTraverser
  • postTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser, AnalyzeTraverser
  • postTraverseMap() : Traverser
  • postTraverseMapColumn() : Traverser, RenderTraverser
  • postTraverseRoot() : Traverser
  • postTraverseTransform() : RenderTraverser, RayIntersectTraverser, ModelViewTraverser, FrustumCullTraverser
  • preAddChild() : Group
  • preApply() : Traverser
  • preCalculateFileSize() : NBFSaveTraverser
  • PreCreateWindow() : GLMFCRAWnd
  • preRemoveChild() : Group
  • preTraverseDrawable() : Traverser
  • preTraverseDrawables() : Traverser, RenderTraverser
  • preTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser, AnalyzeTraverser
  • preTraverseMap() : Traverser, RenderTraverser
  • preTraverseMapColumn() : Traverser, RenderTraverser
  • preTraverseRoot() : Traverser, ModelViewTraverser, FrustumCullTraverser
  • preTraverseTransform() : RenderTraverser, RayIntersectTraverser, ModelViewTraverser, FrustumCullTraverser
  • previousFrame() : AnimationManipulator
  • PrimitiveAttribute() : PrimitiveAttribute
  • PrimitiveSet() : PrimitiveSet
  • PrimitiveSetCombineTraverser() : PrimitiveSetCombineTraverser
  • primitiveSetsBegin() : RenderTraverser, GLTraverser
  • primitiveSetsEnd() : RenderTraverser, GLTraverser
  • PrimitiveSetUnifyTraverser() : PrimitiveSetUnifyTraverser
  • ProblemInfo() : ProblemInfo
  • projectOntoTBSphere() : Trackball
  • pseudoAlloc() : NBFSaveTraverser
  • push() : Path
  • pushCullTraverser() : RenderArea
  • pushModelToWorld() : TransformStack

- q -

  • QuadMeshes() : QuadMeshes
  • quadraticAttenuation : NVSGLight
  • Quads() : Quads
  • QuadStrips() : QuadStrips
  • Quatf() : Quatf
  • queryInterfaceType : PlugInServer

- r -

  • ranges : NBFLOD
  • RayIntersectTraverser() : RayIntersectTraverser
  • RayIntersectTraverser::getWorldIntersection() : RayIntersectTraverser
  • RCIPtr() : RCIPtr
  • RCObject() : RCObject
  • RCObject_AutoPtr() : RCObject_AutoPtr
  • RCPtr() : RCPtr
  • RCVector() : RCVector
  • reducedCount : EquivalenceResult
  • RegVal() : RegVal
  • release() : RCObject_AutoPtr, RayIntersectTraverser
  • releaseDeviceAbstractionLinkData() : DALDataCreator, DALHost
  • releaseImages() : TextureImage
  • releaseInterface : PlugInServer
  • reloadSamplerTextureImage() : CgFxEffect
  • reloadTextureImage() : TextureAttributeItem
  • removeAttribute() : StateVariant, StateSet, StatePass
  • removeAttributeByObjectCode() : StateVariant, StateSet, StatePass
  • removeBuffers() : GLObjects
  • removeCamera() : Scene
  • removeCameraAnimation() : Scene
  • removeChild() : Group
  • removeColumn() : MapMatrix
  • removeGeometry() : GeoNode
  • removeHeadLight() : Camera
  • removeHints() : Node
  • removeLists() : GLObjects
  • removeMap() : MapMatrix, MapArray
  • removeMapObject() : MapList
  • removeOcclusionQueries() : GLObjects
  • removeOnDestroyCallback() : RCObject
  • removePass() : StateVariant, StateSet
  • removePrimitiveSet() : Shape
  • removePrograms() : GLObjects
  • removeQueries() : GLObjects
  • removeRef() : PointerReference, RCObject
  • removeTextures() : GLObjects
  • removeVariant() : StateSet
  • renderAnimatedQuads() : RenderTraverser, GLTraverser
  • renderAnimatedTriangles() : RenderTraverser, GLTraverser
  • RenderArea() : RenderArea
  • renderBegin() : RenderTraverser, GLTraverser
  • renderBlendAttribute() : RenderTraverser, GLTraverser
  • renderCgFx() : RenderTraverser
  • renderDepthAttribute() : RenderTraverser, GLTraverser
  • renderDirectedLight() : RenderTraverser, GLTraverser
  • renderEnd() : RenderTraverser, GLTraverser
  • renderFaceAttribute() : RenderTraverser, GLTraverser
  • renderHighlightBox() : RenderTraverser, GLTraverser
  • renderHighlightEdges() : 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
  • RenderTraverser() : RenderTraverser
  • renderTriangles() : RenderTraverser, GLTraverser
  • renderTriFans() : RenderTraverser, GLTraverser
  • renderTriStrips() : RenderTraverser, GLTraverser
  • replaceChild() : Group
  • replaceDrawable() : GeoNode
  • replaceMap() : MapMatrix, MapArray
  • replaceMapObject() : MapList
  • replacePass() : StateVariant, StateSet
  • replaceStateSet() : GeoNode
  • replaceVariant() : StateSet
  • replaceVariantKey() : StateSet
  • requestHWFSAA() : RenderArea
  • requestStereoSupport() : RenderArea
  • reserved : NBFHeader
  • reset() : RCObject_AutoPtr, Lockable, WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator, Offset_AutoPtr
  • resetButtonState() : MouseInput
  • resetKeyState() : KeyInput
  • resetLightValues() : CgFxEffect
  • resetMaterialValues() : CgFxEffect
  • resetPass() : CgFxEffect
  • resetPositions() : MouseInput
  • root : NBFScene
  • ROTATE : TrackballTransformManipulator
  • rotate() : Camera
  • rotateX() : Camera
  • rotateY() : Camera
  • rotateZ() : Camera
  • RT_EFFECTED : RenderTraverser
  • RT_SHADED : RenderTraverser
  • RT_TEXTURED : RenderTraverser
  • RT_UNLIT : RenderTraverser

- s -

  • save() : SceneSaver, NVSGSaver, NBFSaver
  • scale() : TextureImage
  • scaleOrientation : trafo_t
  • scaling : trafo_t
  • Scene() : Scene
  • scene : NBFHeader
  • search() : SearchTraverser
  • SearchTraverser() : SearchTraverser
  • secondaryColorDim : NBFVertexAttributeSet
  • secondaryColors : NBFVertexAttributeSet
  • secondLastModified : NBFHeader
  • set() : Vec4f, Vec3f, Vec2f, Mat44f, Mat33f
  • setActive() : Switch
  • setActiveVariantKey() : StateSet
  • setAlignment() : MapMatrix, MapArray
  • setAmbientColor() : Scene, Material, LightSource
  • setAnimation() : ViewState, Bone, LightSource, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • setAnimationFrame() : ViewState, SkinnedTriangles, LightSource, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • setAnnotation() : Node
  • setAntiAliasing() : PointAttribute, LineAttribute
  • setAppTraverser() : RenderArea
  • setAspectRatio() : Camera
  • setAttenuation() : SpotLight, PointLight
  • setAutoClipPlanes() : Camera
  • setBackColor() : Scene
  • setBaseClassSearch() : SearchTraverser
  • setBlendFunctions() : BlendAttribute
  • setBoolParameterValue() : CgFxEffect
  • setBorderColor() : TextureAttributeItem
  • setCallback() : PlugIn
  • setCamClipping() : RayIntersectTraverser
  • setCamera() : ViewState
  • setCameraAnimation() : AnimationManipulator
  • setCenter() : LOD, Trafo, Sphere3f
  • setCgFxAwareness() : RenderTraverser
  • setClassName() : SearchTraverser
  • setClipPlane() : RenderTraverser, GLTraverser, Group
  • setColor() : HighlightEdges, HighlightBox, Bitmap
  • setColors() : VertexAttributeSet
  • setCreaseAngle() : SmoothTraverser
  • setCullMode() : FaceAttribute
  • setCullTree() : ViewState
  • setCurrent() : InterpolatedAnimation
  • setCurrentTechnique() : CgFxEffect
  • setCutoffAngle() : SpotLight
  • setDepthFunction() : DepthAttribute
  • setDepthTestingEnabled() : DepthAttribute
  • setDepthWritingEnabled() : DepthAttribute
  • setDiffuseColor() : Material, LightSource
  • setDirection() : SpotLight, DirectedLight, Camera
  • setEmissiveColor() : Material
  • setEnvColor() : TextureAttributeItem
  • setEnvMode() : TextureAttributeItem
  • setEpsilon() : VertexUnifyTraverser
  • setFaceCulling() : RenderTraverser
  • setFaceCullingOverwrite() : RenderTraverser
  • setFaceMode() : RenderTraverser, FaceAttribute
  • setFaceModeOverwrite() : RenderTraverser
  • setFaces() : Triangles, Quads
  • setFalloffExponent() : SpotLight
  • setFarDistance() : Camera
  • setFieldOfView() : PerspectiveCamera
  • setFILE() : NVSGSaveTraverser
  • setFloatParameterValue() : CgFxEffect
  • setFocusDistance() : PerspectiveCamera, Camera
  • setFogCoords() : VertexAttributeSet
  • setGeometryCacheTechnique() : RenderTraverser, GLTraverser
  • setHints() : Node
  • setHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • setIdentity() : Matnnf, Trafo
  • setIgnoreNames() : OptimizeTraverser
  • setIgnoreShares() : PrimitiveSetCombineTraverser
  • setInactive() : Switch
  • setIndices() : IndependentPrimitiveSet
  • setIntensity() : LightSource
  • setIntParameterValue() : CgFxEffect
  • setInverse() : Bone
  • setJitter() : ViewState
  • setJitterTechnique() : RenderTraverser, GLTraverser
  • setKeyFrame() : InterpolatedAnimation
  • 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
  • setMapList() : ViewState
  • setMaterialAmbientValue() : CgFxEffect
  • setMaterialDiffuseValue() : CgFxEffect
  • setMaterialEmissionValue() : CgFxEffect
  • setMaterialShininessValue() : CgFxEffect
  • setMaterialSpecularValue() : CgFxEffect
  • setMatrix() : Bone, Trafo
  • setMaxNumberOfVertices() : PrimitiveSetCombineTraverser
  • setMeshes() : MeshedPrimitiveSet
  • setMinFilterMode() : TextureAttributeItem
  • setMinimalLengths() : StrippingTraverser
  • setName() : Object
  • setNearDistance() : Camera
  • setNormals() : VertexAttributeSet
  • setNumberOfFrames() : AnimationManipulator, FramedAnimation
  • setNumberOfKeys() : InterpolatedAnimation
  • setOcclusionCulling() : RenderTraverser
  • setOITMaxPasses() : RenderTraverser, GLTraverser
  • setOITTechnique() : RenderTraverser, GLTraverser
  • setOITThreshold() : RenderTraverser
  • setOpacity() : Material
  • setOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • setParameterValueAsFloat() : CgFxEffect
  • setPlugInFileFilter : PlugInServer
  • setPointAntiAliasing() : RenderTraverser
  • setPointSize() : RenderTraverser
  • setPolygonOffset() : FaceAttribute
  • setPosition() : SpotLight, PointLight, MapObject, Camera
  • setProgramProfile() : CgFxEffect
  • setRadius() : Sphere3f
  • setRangeLock() : LOD
  • setRanges() : LOD
  • setRay() : RayIntersectTraverser
  • setRelation() : MapObject
  • setRenderArea() : Manipulator
  • setRenderTechnique() : RenderTraverser
  • setRenderTraverser() : RenderArea
  • setRootNode() : Scene
  • setRotationAxis() : Billboard
  • setSamplerTextureImageSpec() : CgFxEffect
  • setScaleOrientation() : Trafo
  • setScaling() : TextureAttributeItem, Trafo
  • setScene() : RenderArea
  • setSceneData() : RenderArea
  • setScreenAligned() : Billboard
  • setScreenSize() : WalkCameraManipulator
  • setSecondaryColors() : VertexAttributeSet
  • setSegments() : Lines
  • setSeparateSpecularColor() : GLTraverser
  • setShadowCasting() : LightSource
  • setShadowMapIntensity() : RenderTraverser
  • setShadowMapSize() : RenderTraverser, GLTraverser
  • setShadowTechnique() : RenderTraverser, GLTraverser
  • setSize() : Trackball, PointAttribute
  • setSkins() : SkinnedTriangles
  • setSortingPolicy() : RenderTraverser
  • setSpacing() : MapMatrix, MapArray
  • setSpecularColor() : Material, LightSource
  • setSpecularExponent() : Material
  • setSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • setSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • setStereo() : ViewState
  • setStereoAutomaticEyeDistanceAdjustment() : ViewState
  • setStereoAutomaticEyeDistanceFactor() : ViewState
  • setStereoEyeDistance() : ViewState
  • setStippleFactor() : LineAttribute
  • setStipplePattern() : LineAttribute
  • setStringParameterValue() : CgFxEffect
  • setStrips() : StrippedPrimitiveSet
  • setTargetDistance() : ViewState
  • setTexCoords() : VertexAttributeSet
  • setTexGenLinearPlane() : TextureAttributeItem
  • setTexGenMode() : TextureAttributeItem
  • setTextureImageSpec() : TextureAttributeItem
  • setTextureSizeLimit() : RenderTraverser, GLTraverser
  • 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
  • setUpVector() : Camera
  • setVertexAttributeData() : VertexAttributeSet
  • setVertexAttributeIndex() : NormalizeTraverser
  • setVertexAttributeSet() : PrimitiveSet
  • setVertices() : VertexAttributeSet
  • setViewportSize() : GLMFCRAWnd, RenderArea, GLWinRenderArea, RayIntersectTraverser
  • setViewState() : RenderArea, ModelViewTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • setViewToClip() : TransformStack
  • setVSensitivity() : FlightCameraManipulator
  • setWeight() : Bone
  • setWidth() : LineAttribute
  • setWindowOffset() : Camera
  • setWindowRegion() : Camera
  • setWindowSize() : Camera
  • setWorldToView() : TransformStack
  • setWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • setWrapMode() : TextureAttributeItem
  • ShadowTechnique : RenderTraverser
  • Shape() : Shape
  • shareLists() : GLWinRenderArea
  • shininess : NVSGMaterial
  • shortStrippedCount : ShortStrippedResult
  • shortStrippedNumber : ShortStrippedResult
  • signature : NBFHeader
  • signedDistance() : Plane3f
  • singleChildCount : SingleChildResult
  • size : NBFPointAttribute
  • SkinnedTriangles() : SkinnedTriangles
  • skins : NBFSkinnedTriangles
  • smoothNormals() : Vec3f
  • SmoothTraverser() : SmoothTraverser
  • SortingPolicy : RenderTraverser
  • source : NBFCgFx
  • sourceFunction : NBFBlendAttribute
  • sourceObject : NBFObject
  • SP_DEPTH : RenderTraverser
  • SP_NONE : RenderTraverser
  • SP_STATE : RenderTraverser
  • specular : NVSGMaterial, NVSGLight
  • specularColor : NBFLightSource
  • Sphere3f() : Sphere3f
  • spotCutoff : NVSGLight
  • spotExponent : NVSGLight
  • SpotLight() : SpotLight
  • ST_NONE : RenderTraverser
  • ST_SHADOW_MAP : RenderTraverser
  • stateAttribs : NBFStatePass
  • StateAttribute() : StateAttribute
  • StatePass() : StatePass
  • statePasses : NBFStateVariant
  • stateSet : geometrySet_t
  • StateSet() : StateSet
  • StateSetUnifyTraverser() : StateSetUnifyTraverser
  • 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
  • Switch() : Switch
  • SwitchToGroupTraverser() : SwitchToGroupTraverser
  • systemHints : NBFNode
  • systemSpecificErrorCode : PlugInCallback::FileMappingFailedInfo, PlugInCallback::FileAccessFailedInfo

- t -

  • targetDistance : NBFViewState
  • testEntry() : MemFunTbl
  • texAttribItem : texBinding_t
  • texBorderColor : NBFTextureAttributeItem
  • texCoords : texCoordSet_t
  • texCoordsSets : NBFVertexAttributeSet
  • texEnvColor : NBFTextureAttributeItem
  • texEnvMode : NBFTextureAttributeItem
  • texGenMode : NBFTextureAttributeItem
  • texGenPlane : NBFTextureAttributeItem
  • texImg : NBFTextureAttributeItem, sampler_t
  • TextureAttribute() : TextureAttribute
  • TextureAttributeItem() : TextureAttributeItem
  • TextureAttributeItemData() : TextureAttributeItemData
  • TextureImage() : TextureImage
  • texUnit : texBinding_t
  • texWrapR : NBFTextureAttributeItem
  • texWrapS : NBFTextureAttributeItem
  • texWrapT : NBFTextureAttributeItem
  • theAllocator : IAllocator
  • TILT : WalkCameraManipulator
  • toggleStereo() : ViewState
  • token : PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::EmptyTokenInfo
  • Trace() : Trace
  • Trackball() : Trackball
  • TrackballCameraManipulator() : TrackballCameraManipulator
  • TrackballTransformManipulator() : TrackballTransformManipulator
  • trafo : NBFTextureAttributeItem
  • Trafo() : Trafo
  • TRAFO_MODEL : CgFxEffect
  • TRAFO_MODELI : CgFxEffect
  • TRAFO_MODELIT : CgFxEffect
  • TRAFO_MODELT : CgFxEffect
  • TRAFO_MODELVIEW : CgFxEffect
  • TRAFO_MODELVIEWI : CgFxEffect
  • TRAFO_MODELVIEWIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTION : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONI : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONT : CgFxEffect
  • TRAFO_MODELVIEWT : CgFxEffect
  • TRAFO_PROJECTION : CgFxEffect
  • TRAFO_PROJECTIONI : CgFxEffect
  • TRAFO_PROJECTIONIT : CgFxEffect
  • TRAFO_PROJECTIONT : CgFxEffect
  • TRAFO_UNKNOWN : CgFxEffect
  • TRAFO_VIEW : CgFxEffect
  • TRAFO_VIEWI : CgFxEffect
  • TRAFO_VIEWIT : CgFxEffect
  • TRAFO_VIEWT : CgFxEffect
  • TRAFO_WORLD : CgFxEffect
  • TRAFO_WORLDI : CgFxEffect
  • TRAFO_WORLDIT : CgFxEffect
  • TRAFO_WORLDT : CgFxEffect
  • TRAFO_WORLDVIEW : CgFxEffect
  • TRAFO_WORLDVIEWI : CgFxEffect
  • TRAFO_WORLDVIEWIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTION : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONI : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONT : CgFxEffect
  • TRAFO_WORLDVIEWT : CgFxEffect
  • trafos : NBFTrafoAnimation
  • Transform() : Transform
  • TransformCombineTraverser() : TransformCombineTraverser
  • TransformManipulator() : TransformManipulator
  • TransformStack() : TransformStack
  • TransformType : CgFxEffect
  • TRANSLATE : WalkCameraManipulator
  • translation : trafo_t
  • TransparencyTechnique : RenderTraverser
  • transparentBegin() : RenderTraverser, GLTraverser
  • transparentEnd() : RenderTraverser, GLTraverser
  • traverseHighlightObject() : Traverser
  • traverseLight() : Traverser, RenderTraverser, CullTraverser, AppTraverser
  • traverseObject() : Traverser
  • traversePrimitiveSet() : VertexAttributeSetUnifyTraverser, Traverser, RenderTraverser, CullTraverser
  • Traverser() : Traverser
  • Triangles() : Triangles
  • TriangulateTraverser() : TriangulateTraverser
  • TriFans() : TriFans
  • triggerRedraw() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • TriStrips() : TriStrips
  • truncate() : Path
  • TT_BLENDED : RenderTraverser
  • TT_NONE : RenderTraverser
  • TT_ORDER_INDEPENDENT : RenderTraverser
  • TT_SORTED_BLENDED : RenderTraverser
  • TT_STIPPLED : RenderTraverser
  • tweaks : tweak_t
  • twoSidedLighting : NBFFaceAttribute

- u -

  • unbindTextureAttributeItem() : TextureAttribute
  • unloadPrograms() : CgFx
  • unmapOffset() : NBFLoader
  • unmapViewOfFile() : NBFSaveTraverser
  • updateFrame() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator
  • UPIID() : UPIID
  • UPITID() : UPITID
  • upVector : NBFCamera
  • userHints : NBFNode

- v -

  • validate() : HighlightObject, HighlightBox
  • validateCurrentTechnique() : CgFxEffect
  • validateIncarnation() : TextureAttribute, StateVariant, StateSet, StatePass, SkinnedTriangles, Shape, PrimitiveSet, Object, MapMatrix, MapList, MapElement, MapArray, LightSource, Group, GeoNode, Drawable, Camera, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • 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
  • Vec2f() : Vec2f
  • Vec3f() : Vec3f
  • Vec4f() : Vec4f
  • Vecnf() : Vecnf
  • vertex : skin_t
  • vertexAttributeSet : NBFPrimitiveSet
  • VertexAttributeSet() : VertexAttributeSet
  • VertexAttributeSetUnifyTraverser() : VertexAttributeSetUnifyTraverser
  • vertexSets : NBFVNVectorAnimation
  • VertexUnifyTraverser() : VertexUnifyTraverser
  • vertices : VNVector, NBFVertexAttributeSet
  • viewState : NBFHeader
  • ViewState() : ViewState

- w -

  • waitToRead() : ISWMRSync
  • waitToWrite() : ISWMRSync
  • WALKBACKWARD : WalkCameraManipulator
  • WalkCameraManipulator() : WalkCameraManipulator
  • WALKFORWARD : WalkCameraManipulator
  • wasRenderInterrupted() : RenderArea
  • wasTraversalInterrupted() : Traverser
  • weight : bone_t
  • WGLBindSwapBarrierNV : GLContext
  • WGLBindTexImage : GLContext
  • WGLChoosePixelFormat : GLContext
  • WGLCreateContext : GLContext
  • WGLCreatePbuffer : GLContext
  • WGLDeleteContext : GLContext
  • WGLDestroyPbuffer : 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
  • WRLLoadTraverser() : WRLLoadTraverser

- y -

  • yearLastModified : NBFHeader

- z -

  • zoom() : Camera

- ~ -

  • ~Allocator() : Allocator
  • ~AnalyzeResult() : AnalyzeResult
  • ~AnalyzeTraverser() : AnalyzeTraverser
  • ~AnimatedQuads() : AnimatedQuads
  • ~AnimatedTransform() : AnimatedTransform
  • ~AnimatedTriangles() : AnimatedTriangles
  • ~Animation() : Animation
  • ~AnimationManipulator() : AnimationManipulator
  • ~AppTraverser() : AppTraverser
  • ~Billboard() : Billboard
  • ~Bitmap() : Bitmap
  • ~BlendAttribute() : BlendAttribute
  • ~Bone() : Bone
  • ~Camera() : Camera
  • ~CgFx() : CgFx
  • ~CullData() : CullData
  • ~CullTraverser() : CullTraverser
  • ~DepthAttribute() : DepthAttribute
  • ~DestrippingTraverser() : DestrippingTraverser
  • ~DirectedLight() : DirectedLight
  • ~Drawable() : Drawable
  • ~EmptyResult() : EmptyResult
  • ~EquivalenceResult() : EquivalenceResult
  • ~FaceAttribute() : FaceAttribute
  • ~FixedAllocator() : FixedAllocator
  • ~FlightCameraManipulator() : FlightCameraManipulator
  • ~FramedAnimation() : FramedAnimation
  • ~FrustumCullTraverser() : FrustumCullTraverser
  • ~GeoNode() : GeoNode
  • ~GeoNodeCombineTraverser() : GeoNodeCombineTraverser
  • ~GeoNodeUnifyTraverser() : GeoNodeUnifyTraverser
  • ~GLFunctions() : GLFunctions
  • ~GLMFCRAWnd() : GLMFCRAWnd
  • ~GLObjects() : GLObjects
  • ~GLTraverser() : GLTraverser
  • ~GLWinRenderArea() : GLWinRenderArea
  • ~Group() : Group
  • ~GroupEliminateTraverser() : GroupEliminateTraverser
  • ~HighlightEdges() : HighlightEdges
  • ~HighlightObject() : HighlightObject
  • ~IAllocator() : IAllocator
  • ~IdentityResult() : IdentityResult
  • ~IdentityToGroupTraverser() : IdentityToGroupTraverser
  • ~ILTexLoader() : ILTexLoader
  • ~IndependentPrimitiveSet() : IndependentPrimitiveSet
  • ~InterpolatedAnimation() : InterpolatedAnimation
  • ~Intersection() : Intersection
  • ~KeyInput() : KeyInput
  • ~LightSource() : LightSource
  • ~LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • ~LineAttribute() : LineAttribute
  • ~Lines() : Lines
  • ~LineStrips() : LineStrips
  • ~Lockable() : Lockable
  • ~LOD() : LOD
  • ~LODCombineTraverser() : LODCombineTraverser
  • ~LODEliminateTraverser() : LODEliminateTraverser
  • ~Manipulator() : Manipulator
  • ~Map() : Map
  • ~MapArray() : MapArray
  • ~MapElement() : MapElement
  • ~MapList() : MapList
  • ~MapMatrix() : MapMatrix
  • ~MapObject() : MapObject
  • ~Material() : Material
  • ~MeshedPrimitiveSet() : MeshedPrimitiveSet
  • ~MissingResult() : MissingResult
  • ~ModelViewTraverser() : ModelViewTraverser
  • ~MouseInput() : MouseInput
  • ~NBFLoader() : NBFLoader
  • ~Node() : Node
  • ~NormalizeTraverser() : NormalizeTraverser
  • ~NVBLoader() : NVBLoader
  • ~NVBLoadTraverser() : NVBLoadTraverser
  • ~Object() : Object
  • ~Offset_AutoPtr() : Offset_AutoPtr
  • ~OptimizeTraverser() : OptimizeTraverser
  • ~ParallelCamera() : ParallelCamera
  • ~Path() : Path
  • ~PerspectiveCamera() : PerspectiveCamera
  • ~PlugInCallback() : PlugInCallback
  • ~PointAttribute() : PointAttribute
  • ~PointLight() : PointLight
  • ~Points() : Points
  • ~PrimitiveAttribute() : PrimitiveAttribute
  • ~PrimitiveSet() : PrimitiveSet
  • ~PrimitiveSetCombineTraverser() : PrimitiveSetCombineTraverser
  • ~PrimitiveSetUnifyTraverser() : PrimitiveSetUnifyTraverser
  • ~QuadMeshes() : QuadMeshes
  • ~Quads() : Quads
  • ~QuadStrips() : QuadStrips
  • ~RayIntersectTraverser() : RayIntersectTraverser
  • ~RCIPtr() : RCIPtr
  • ~RCObject() : RCObject
  • ~RCObject_AutoPtr() : RCObject_AutoPtr
  • ~RCPtr() : RCPtr
  • ~RegVal() : RegVal
  • ~RenderArea() : RenderArea
  • ~RenderTraverser() : RenderTraverser
  • ~Scene() : Scene
  • ~SceneLoader() : SceneLoader
  • ~SceneSaver() : SceneSaver
  • ~SearchTraverser() : SearchTraverser
  • ~Shape() : Shape
  • ~SingleChildResult() : SingleChildResult
  • ~SkinnedTriangles() : SkinnedTriangles
  • ~SmoothTraverser() : SmoothTraverser
  • ~SpotLight() : SpotLight
  • ~StateAttribute() : StateAttribute
  • ~StatePass() : StatePass
  • ~StateSet() : StateSet
  • ~StateSetUnifyTraverser() : StateSetUnifyTraverser
  • ~StateVariant() : StateVariant
  • ~StrippedPrimitiveSet() : StrippedPrimitiveSet
  • ~StrippingTraverser() : StrippingTraverser
  • ~Switch() : Switch
  • ~SwitchToGroupTraverser() : SwitchToGroupTraverser
  • ~TextureAttribute() : TextureAttribute
  • ~TextureAttributeItem() : TextureAttributeItem
  • ~TextureLoader() : TextureLoader
  • ~Trace() : Trace
  • ~Trackball() : Trackball
  • ~TrackballCameraManipulator() : TrackballCameraManipulator
  • ~TrackballTransformManipulator() : TrackballTransformManipulator
  • ~Transform() : Transform
  • ~TransformCombineTraverser() : TransformCombineTraverser
  • ~TransformManipulator() : TransformManipulator
  • ~Traverser() : Traverser
  • ~Triangles() : Triangles
  • ~TriangulateTraverser() : TriangulateTraverser
  • ~TriFans() : TriFans
  • ~TriStrips() : TriStrips
  • ~VertexAttributeSet() : VertexAttributeSet
  • ~VertexAttributeSetUnifyTraverser() : VertexAttributeSetUnifyTraverser
  • ~VertexUnifyTraverser() : VertexUnifyTraverser
  • ~ViewState() : ViewState
  • ~WalkCameraManipulator() : WalkCameraManipulator
  • ~WRLLoadTraverser() : WRLLoadTraverser
Generated on Fri Aug 4 08:36:29 2006 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions

  • GeometryCacheTechnique : RenderTraverser
  • ISType : RayIntersectTraverser
  • JitterTechnique : RenderTraverser
  • NodeHints : Node
  • OITTechnique : RenderTraverser
  • PIC_ERROR : PlugInCallback
  • PIC_TYPE_ID : PlugInCallback
  • PIC_WARNING : PlugInCallback
  • PixelDataType : TextureImage
  • PixelFormat : TextureImage
  • RenderTechnique : RenderTraverser
  • ShadowTechnique : RenderTraverser
  • SortingPolicy : RenderTraverser
  • TransformType : CgFxEffect
  • TransparencyTechnique : RenderTraverser
Generated on Fri Aug 4 08:36:30 2006 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
_ | f | g | i | j | n | o | r | s | t

- _ -

  • _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
  • _MULTISAMPLE : RenderArea
  • _NO_BTN_KEY : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • _NONE : RayIntersectTraverser
  • _S_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _SHIFT_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _STEREO : RenderArea
  • _UNDEFINED : RenderArea
  • _W_KEY : WalkCameraManipulator, FlightCameraManipulator
  • _X_KEY : TrackballTransformManipulator, TrackballCameraManipulator
  • _Y_KEY : TrackballTransformManipulator, TrackballCameraManipulator

- f -

  • F_IMAGE_STREAM : 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

- g -

  • GCT_DL : RenderTraverser
  • GCT_NONE : RenderTraverser
  • GCT_VBO : RenderTraverser

- i -

  • IMG_BGR : TextureImage
  • IMG_BGRA : TextureImage
  • IMG_BYTE : TextureImage
  • IMG_COLOR_INDEX : TextureImage
  • IMG_FLOAT : TextureImage
  • IMG_HALF : TextureImage
  • IMG_INT : TextureImage
  • IMG_LUMINANCE : TextureImage
  • IMG_LUMINANCE_ALPHA : TextureImage
  • IMG_RGB : TextureImage
  • IMG_RGBA : TextureImage
  • IMG_SHORT : TextureImage
  • IMG_UNKNOWN_FORMAT : TextureImage
  • IMG_UNKNOWN_TYPE : TextureImage
  • IMG_UNSIGNED_BYTE : TextureImage
  • IMG_UNSIGNED_INT : TextureImage
  • IMG_UNSIGNED_SHORT : TextureImage

- j -

  • JT_ACCUM : 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

- o -

  • OT_PBUFFER : RenderTraverser
  • OT_TEXTURE : RenderTraverser

- 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_MODELIT : CgFxEffect
  • TRAFO_MODELT : CgFxEffect
  • TRAFO_MODELVIEW : CgFxEffect
  • TRAFO_MODELVIEWI : CgFxEffect
  • TRAFO_MODELVIEWIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTION : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONI : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_MODELVIEWPROJECTIONT : CgFxEffect
  • TRAFO_MODELVIEWT : CgFxEffect
  • TRAFO_PROJECTION : CgFxEffect
  • TRAFO_PROJECTIONI : CgFxEffect
  • TRAFO_PROJECTIONIT : CgFxEffect
  • TRAFO_PROJECTIONT : CgFxEffect
  • TRAFO_UNKNOWN : CgFxEffect
  • TRAFO_VIEW : CgFxEffect
  • TRAFO_VIEWI : CgFxEffect
  • TRAFO_VIEWIT : CgFxEffect
  • TRAFO_VIEWT : CgFxEffect
  • TRAFO_WORLD : CgFxEffect
  • TRAFO_WORLDI : CgFxEffect
  • TRAFO_WORLDIT : CgFxEffect
  • TRAFO_WORLDT : CgFxEffect
  • TRAFO_WORLDVIEW : CgFxEffect
  • TRAFO_WORLDVIEWI : CgFxEffect
  • TRAFO_WORLDVIEWIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTION : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONI : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONIT : CgFxEffect
  • TRAFO_WORLDVIEWPROJECTIONT : CgFxEffect
  • TRAFO_WORLDVIEWT : CgFxEffect
  • TT_BLENDED : RenderTraverser
  • TT_NONE : RenderTraverser
  • TT_ORDER_INDEPENDENT : RenderTraverser
  • TT_SORTED_BLENDED : RenderTraverser
  • TT_STIPPLED : RenderTraverser
Generated on Fri Aug 4 08:36:30 2006 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
  • addAttribute() : StateVariant, StateSet, StatePass
  • addBuffers() : GLObjects
  • addCamera() : Scene
  • addCameraAnimation() : Scene
  • addChild() : Group, CullData
  • addClipPlane() : Group
  • addEmptyColumn() : MapMatrix
  • addEntry() : MemFunTbl
  • addGeometry() : GeoNode
  • addHeadLight() : Camera
  • addHints() : Node
  • addLists() : GLObjects
  • addMap() : MapMatrix, MapArray
  • addMapObject() : MapList
  • addObjectHandler() : Traverser
  • addObjectRenderer() : RenderTraverser
  • addOcclusionQueries() : GLObjects
  • addOnDestroyCallback() : RCObject
  • addPass() : StateVariant, StateSet
  • addPrimitiveSet() : Shape
  • addPrograms() : GLObjects
  • addQueries() : GLObjects
  • addRef() : PointerReference, RCObject
  • addTextures() : GLObjects
  • addVariant() : StateSet
  • alloc() : Allocator, FixedAllocator, Chunk, Offset_AutoPtr, NBFSaveTraverser
  • Allocator() : Allocator
  • AnalyzeTraverser() : AnalyzeTraverser
  • AnimatedQuads() : AnimatedQuads
  • AnimatedTransform() : AnimatedTransform
  • AnimatedTriangles() : AnimatedTriangles
  • Animation() : Animation
  • AnimationManipulator() : AnimationManipulator
  • apply() : Trackball, Traverser
  • applyPass() : CgFxEffect
  • AppTraverser() : AppTraverser
  • areCollinear() : Vec3f
  • areOnOppositeSides() : Plane3f
  • areOnSameSide() : Plane3f
  • areOpposite() : Vecnf
  • areOrthogonal() : Vecnf
  • areOrthonormal() : Vecnf
  • areSimilar() : Vecnf
  • assertInvalidBoundingSphere() : Node
  • assignCustomLightToEffectLight() : RenderTraverser
  • assignDirectedLightToEffectLight() : RenderTraverser, GLTraverser
  • assignPointLightToEffectLight() : RenderTraverser, GLTraverser
  • assignSpotLightToEffectLight() : RenderTraverser, GLTraverser
  • attachHighlightObject() : Drawable
  • attachWindow() : GLWinRenderArea

- b -

  • balance() : CullData
  • beginEdit() : Traverser
  • beginOcclusionCullQuery() : RenderTraverser, GLTraverser
  • Billboard() : Billboard
  • bindTextureAttributeItem() : TextureAttribute
  • Bitmap() : Bitmap
  • BlendAttribute() : BlendAttribute
  • blocksAvailable() : Chunk
  • Bone() : Bone
  • boundingSphere() : Sphere3f

- c -

  • c() : Plane3f
  • calcNearFarDistances() : Camera
  • calculateBoundingSphere() : Transform, Switch, StrippedPrimitiveSet, Shape, PrimitiveSet, Node, MeshedPrimitiveSet, LightSource, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, Drawable
  • calculateTangentSpace() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • calculatingStorageRequirements() : NBFSaveTraverser
  • callback() : PlugIn
  • Camera() : Camera
  • CgFx() : CgFx
  • checkClipPlanes() : RayIntersectTraverser
  • checkIntersection() : RayIntersectTraverser
  • Chunk() : Chunk
  • clear() : MapList, MapArray
  • clearCullTree() : ViewState
  • clearGeometries() : GeoNode
  • clearHeadLights() : Camera
  • clearRenderLists() : RenderTraverser
  • clearTexCoords() : VertexAttributeSet, GeoNode
  • clearVertexAttributeData() : VertexAttributeSet
  • clone() : CullData, Intersection, ViewState, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Node, MeshedPrimitiveSet, Material, MapObject, MapMatrix, MapList, MapElement, MapArray, Map, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, IndependentPrimitiveSet, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Bitmap, Billboard, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • compileProgram() : CgFxEffect
  • containsCgFx() : StateVariant, StateSet, StatePass, Scene, Node, Group, GeoNode
  • containsHints() : Node
  • containsLight() : Scene, Node, LightSource, Group
  • containsTransparentGeometry() : Scene, Node
  • convert2DToCubeMap() : TextureImage
  • create() : ViewState, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, Scene, QuadStrips, Quads, QuadMeshes, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Material, MapMatrix, MapList, MapElement, MapArray, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, DirectedLight, DepthAttribute, CgFx, BlendAttribute, Bitmap, Billboard, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • createFromBase() : TriStrips, TriFans, Triangles, Transform, TextureAttribute, TextureAttributeItem, Switch, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, QuadStrips, Quads, QuadMeshes, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Material, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, DirectedLight, DepthAttribute, BlendAttribute, Billboard, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • createFromFile() : TextureImage, CgFxEffect
  • createFromLump() : CgFxEffect
  • createImage() : TextureImage
  • createMipmaps() : TextureImage
  • createNewRenderAreaID() : RenderArea
  • createOcclusionCullID() : RenderTraverser, GLTraverser
  • cullCode() : FrustumCullTraverser, CullTraverser
  • CullData() : CullData
  • CullTraverser() : CullTraverser

- d -

  • DALData() : DALData
  • deactivateClipPlane() : Group
  • dealloc() : Allocator, FixedAllocator, Chunk, NBFSaveTraverser
  • decompose() : Quatf, Mat44f, Mat33f
  • decrementMipmapUseCount() : TextureImage
  • deleteThis() : PlugIn, DALData, NVSGSaver, NBFSaver, WRLLoader, NVSGLoader, NVBLoader, NBFLoader, ILTexLoader
  • demandUpload() : TextureImage
  • DepthAttribute() : DepthAttribute
  • DestrippingTraverser() : DestrippingTraverser
  • destroy() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • destroyOcclusionCullID() : RenderTraverser, GLTraverser
  • determinant() : Mat33f
  • determineCullCode() : PerspectiveCamera, ParallelCamera, Camera
  • determineHintsContainment() : Switch, Node, Group
  • determinePixelFormat() : GLWinRenderArea
  • determineTransparencyContainment() : Switch, Node, LightSource, Group, GeoNode
  • DirectedLight() : DirectedLight
  • disableHWFSAA() : GLWinRenderArea
  • distance() : Vecnf, Quatf, Plane3f
  • doApply() : VertexUnifyTraverser, VertexAttributeSetUnifyTraverser, Traverser, SwitchToGroupTraverser, StateSetUnifyTraverser, SmoothTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, OptimizeTraverser, NormalizeTraverser, LODEliminateTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GLTraverser, GeoNodeUnifyTraverser, DestrippingTraverser, CullTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • doneReading() : ISWMRSync
  • doneWriting() : ISWMRSync
  • doRender() : RenderTraverser, GLTraverser
  • Drawable() : Drawable
  • dumpIntersectionList() : RayIntersectTraverser

- e -

  • enableHWFSAA() : GLWinRenderArea
  • endEdit() : Traverser
  • EndImport() : NVNVB
  • endOcclusionCullQuery() : RenderTraverser, GLTraverser

- f -

  • FaceAttribute() : FaceAttribute
  • finishUpload() : TextureImage
  • firstFrame() : AnimationManipulator
  • FixedAllocator() : FixedAllocator
  • FlightCameraManipulator() : FlightCameraManipulator
  • format() : TraceFunctor, Log
  • FramedAnimation() : FramedAnimation
  • freeMemory() : Chunk
  • FrustumCullTraverser() : FrustumCullTraverser

- g -

  • generateNormals() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • generateTexCoords() : VertexAttributeSet, GeoNode
  • GeoNode() : GeoNode
  • GeoNodeCombineTraverser() : GeoNodeCombineTraverser
  • GeoNodeUnifyTraverser() : GeoNodeUnifyTraverser
  • get() : RCObject_AutoPtr, Lockable
  • getActive() : Switch
  • getActiveVariant() : StateSet
  • getActiveVariantKey() : StateSet
  • getAlignment() : MapMatrix, MapArray
  • getAmbientColor() : Scene, Material, LightSource
  • getAnalysis() : AnalyzeTraverser
  • getAnimation() : Bone, LightSource, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • getAnimationFrame() : ViewState
  • getAnnotation() : Node
  • 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
  • getBoolAnnotationValue() : CgFxEffect
  • getBoolParameterValue() : CgFxEffect
  • getBoolPassStateValue() : CgFxEffect
  • getBoolSamplerStateValue() : CgFxEffect
  • getBorderColor() : TextureAttributeItem
  • getBoundingSphere() : Node, HighlightObject, Drawable
  • getButtonState() : MouseInput
  • getBytesPerImage() : TextureImage
  • getBytesPerPixel() : TextureImage
  • getBytesPerScanLine() : TextureImage
  • getCamera() : ViewState, Scene
  • getCameraAnimation() : Scene
  • getCenter() : LOD, Trafo, Sphere3f
  • getChild() : Group, CullData
  • getChildPositions() : Group
  • getClipPlane() : Group
  • getClipToModel() : TransformStack
  • getClipToView() : TransformStack
  • getColor() : HighlightEdges, HighlightBox, Bitmap
  • getColors() : VertexAttributeSet
  • getColorsDim() : VertexAttributeSet
  • getContext() : CgFxEffect
  • getCreationFlags() : TextureImage
  • getCullCode() : CullData
  • getCullTraverser() : RenderArea
  • getCullTree() : ViewState
  • getCurrentCgFx() : RenderTraverser
  • getCurrentFrame() : InterpolatedAnimation
  • getCurrentTechnique() : CgFxEffect
  • getCurrentValue() : InterpolatedAnimation
  • getCurrentX() : MouseInput
  • getCurrentY() : MouseInput
  • getCutoffAngle() : SpotLight
  • getData() : 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
  • getDist() : Intersection
  • getDrawable() : Intersection, GeoNode
  • getEffect() : CgFx
  • getEmissiveColor() : Material
  • getEntrySize() : MapMatrix, MapArray
  • getEnvColor() : TextureAttributeItem
  • getEnvMode() : TextureAttributeItem
  • getErrorMessage() : NVSGException
  • getFaceMode() : RenderTraverser
  • getFaces() : Triangles, Quads
  • getFalloffExponent() : SpotLight
  • getFarDistance() : Camera
  • getFieldOfView() : PerspectiveCamera
  • getFileName() : CgFxEffect
  • getFirstItem() : TextureAttribute
  • getFirstVariantIterator() : StateSet
  • getFloatAnnotationValue() : CgFxEffect
  • getFloatParameterValue() : CgFxEffect
  • getFloatPassStateValue() : CgFxEffect
  • getFloatSamplerStateValue() : CgFxEffect
  • getFocusDistance() : Camera
  • getFogCoords() : VertexAttributeSet
  • getFormat() : TextureImage
  • getFragmentProgram() : CgFxEffect
  • getFrame() : InterpolatedAnimation
  • getFromHead() : Path
  • getFromTail() : Path
  • getFrontFaceMode() : FaceAttribute
  • getGeometryCacheTechnique() : RenderTraverser
  • getGeometryIndex() : GeoNode
  • getHead() : Path
  • getHeadLight() : Camera
  • getHeight() : TextureImage, Map
  • getHigherLevelObjectCode() : Object
  • getHighlightObject() : Drawable
  • getHints() : Node
  • getHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • getIgnoreNames() : OptimizeTraverser
  • getIgnoreShares() : PrimitiveSetCombineTraverser
  • getIncarnation() : Object
  • getIndexOfMap() : MapMatrix, MapArray
  • getIndices() : IndependentPrimitiveSet
  • getIntAnnotationValue() : CgFxEffect
  • getIntensity() : LightSource
  • getInterleavedFormat() : VertexAttributeSet
  • getIntersections() : RayIntersectTraverser
  • getIntParameterValue() : CgFxEffect
  • getIntPassStateValue() : CgFxEffect
  • getIntSamplerStateValue() : CgFxEffect
  • getInverse() : LightSource, Trafo
  • getInverseProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getIsp() : Intersection
  • getJitters() : ViewState
  • getJitterTechnique() : RenderTraverser
  • getKey() : InterpolatedAnimation
  • getKeyState() : KeyInput
  • getLastRecentlyUsedDeviceAbstractionLinkData() : DALHost
  • getLastVariantIterator() : StateSet
  • getLastX() : MouseInput
  • getLastY() : MouseInput
  • getLength() : Path
  • getLight() : CgFxEffect
  • getLightAmbientValue() : CgFxEffect
  • getLightByName() : CgFxEffect
  • getLightBySemantic() : CgFxEffect
  • getLightConstantAttenuationValue() : CgFxEffect
  • getLightDiffuseValue() : CgFxEffect
  • getLightDirectionValue() : CgFxEffect
  • getLightLinearAttenuationValue() : CgFxEffect
  • getLightPositionValue() : CgFxEffect
  • getLightQuadraticAttenuationValue() : CgFxEffect
  • getLightSpecularValue() : CgFxEffect
  • getLightSpotCutoffValue() : CgFxEffect
  • getLightSpotExponentValue() : CgFxEffect
  • getLineWidth() : RenderTraverser, HighlightEdges, HighlightBox
  • getLODRangeScale() : ViewState
  • getLODToUse() : LOD
  • getLowerLeft() : MapObject
  • getMagFilterMode() : TextureAttributeItem
  • getMap() : MapMatrix, MapElement, MapArray
  • getMapList() : ViewState
  • getMapObject() : MapList
  • getMapPosition() : RenderTraverser
  • getMaterial() : CgFxEffect
  • getMaterialAmbientValue() : CgFxEffect
  • getMaterialDiffuseValue() : CgFxEffect
  • getMaterialEmissionValue() : CgFxEffect
  • getMaterialShininessValue() : CgFxEffect
  • getMaterialSpecularValue() : CgFxEffect
  • getMatrix() : TextureAttributeItem, Bone, Trafo
  • getMaxNumberOfVertices() : PrimitiveSetCombineTraverser
  • getMeshes() : MeshedPrimitiveSet
  • getMinFilterMode() : TextureAttributeItem
  • getMinimalLengths() : StrippingTraverser
  • getMipmapUseCount() : TextureImage
  • getModelToClip() : TransformStack
  • getModelToView() : TransformStack
  • getModelToWorld() : TransformStack
  • getModelToWorldMatrix() : Path
  • getName() : Object
  • getNearDistance() : Camera
  • getNearest() : RayIntersectTraverser
  • getNextItem() : TextureAttribute
  • getNextVariantIterator() : StateSet
  • getNormals() : VertexAttributeSet
  • getNumberOfActive() : Switch
  • getNumberOfActiveClipPlanes() : Group
  • getNumberOfAnnotationValueComponents() : CgFxEffect
  • getNumberOfArrayParameterElements() : CgFxEffect
  • getNumberOfAttributes() : StateVariant, StateSet, StatePass
  • getNumberOfCameraAnimations() : Scene
  • getNumberOfCameras() : Scene
  • getNumberOfChildren() : Group, CullData
  • getNumberOfClipPlanes() : Group
  • getNumberOfColors() : VertexAttributeSet
  • getNumberOfColumns() : MapMatrix
  • getNumberOfCullTraverser() : RenderArea
  • getNumberOfDrawables() : GeoNode
  • getNumberOfFaces() : Triangles, Quads
  • getNumberOfFogCoords() : VertexAttributeSet
  • getNumberOfFrames() : SkinnedTriangles, Scene, Node, LightSource, InterpolatedAnimation, Group, GeoNode, FramedAnimation, Drawable, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • getNumberOfGeometries() : GeoNode
  • getNumberOfHeadLights() : Camera
  • getNumberOfImages() : TextureImage
  • getNumberOfIndices() : IndependentPrimitiveSet
  • getNumberOfIntersections() : RayIntersectTraverser
  • getNumberOfItems() : TextureAttribute
  • getNumberOfJitters() : ViewState
  • getNumberOfKeys() : InterpolatedAnimation
  • getNumberOfLights() : CgFxEffect
  • getNumberOfMapObjects() : MapList
  • getNumberOfMaps() : MapMatrix, MapArray
  • getNumberOfMeshes() : MeshedPrimitiveSet
  • getNumberOfMipmaps() : TextureImage
  • getNumberOfNormals() : VertexAttributeSet
  • getNumberOfOwners() : VertexAttributeSet, TextureAttributeItem, StateVariant, StateSet, StatePass, Drawable
  • getNumberOfParameterAnnotations() : CgFxEffect
  • getNumberOfParameterValueComponents() : CgFxEffect
  • getNumberOfParents() : StateAttribute, Node
  • getNumberOfPassAnnotations() : CgFxEffect
  • getNumberOfPasses() : StateVariant, StateSet, CgFxEffect
  • getNumberOfPassStateValueComponents() : CgFxEffect
  • getNumberOfPrimitiveSets() : Shape
  • getNumberOfProgramParameters() : 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
  • getNumberOfVertexAttributeBytes() : VertexAttributeSet
  • getNumberOfVertexAttributeData() : VertexAttributeSet
  • getNumberOfVertices() : VertexAttributeSet
  • getObjectCode() : Object
  • getOcclusionCullResult() : RenderTraverser, GLTraverser
  • getOITMaxPasses() : RenderTraverser
  • getOITTechnique() : RenderTraverser
  • getOITThreshold() : RenderTraverser
  • getOpacity() : Material
  • getOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • getOwner() : VertexAttributeSet, TextureAttributeItem, StateVariant, StateSet, StatePass, Drawable
  • getParameterAnnotation() : CgFxEffect
  • getParameterAnnotationByName() : CgFxEffect
  • getParameterByName() : CgFxEffect
  • getParameterBySemantic() : CgFxEffect
  • getParameterName() : CgFxEffect
  • getParameterSemantic() : CgFxEffect
  • getParameterTypeString() : CgFxEffect
  • getParameterValueAsFloat() : CgFxEffect
  • getParameterValueSize() : CgFxEffect
  • getParent() : StateAttribute, 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() : Shape, HighlightEdges
  • getProblems() : RenderArea, Traverser
  • getProgramParameter() : CgFxEffect
  • getProgramProfile() : CgFxEffect
  • getProjection() : PerspectiveCamera, ParallelCamera, Camera
  • getPtr() : Vecnf, Matnnf
  • getRadius() : Sphere3f
  • getRangeLock() : LOD
  • getRanges() : LOD
  • getRelation() : MapObject
  • getRenderTechnique() : RenderTraverser
  • getRenderTraverser() : RenderArea
  • getResults() : SearchTraverser
  • getRootNode() : Scene
  • getRotationAxis() : Billboard
  • getSampler() : CgFxEffect
  • getSamplerByName() : CgFxEffect
  • getSamplerByTextureParameterName() : CgFxEffect
  • getSamplerTexture() : CgFxEffect
  • getSamplerTextureFileName() : CgFxEffect
  • getSamplerTextureImage() : CgFxEffect
  • getScaleOrientation() : Trafo
  • getScaling() : TextureAttributeItem, Trafo
  • getScene() : RenderArea
  • getSecondaryColors() : VertexAttributeSet
  • getSecondaryColorsDim() : VertexAttributeSet
  • getSegments() : Lines
  • getShadowMapIntensity() : RenderTraverser
  • getShadowMapSize() : RenderTraverser
  • getShadowTechnique() : RenderTraverser
  • getSize() : Trackball, PointAttribute, MapObject, MapMatrix, MapElement, MapArray
  • getSkins() : SkinnedTriangles
  • getSortingPolicy() : RenderTraverser
  • getSourceCode() : CgFxEffect
  • getSourceFunction() : BlendAttribute
  • getSpacing() : MapMatrix, MapArray
  • getSpecularColor() : Material, LightSource
  • getSpecularExponent() : Material
  • getSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • getSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • getStackDepth() : TransformStack
  • getStartX() : MouseInput
  • getStartY() : MouseInput
  • getStateSet() : GeoNode
  • getStereoAutomaticEyeDistanceFactor() : ViewState
  • getStereoEyeDistance() : ViewState
  • getStippleFactor() : LineAttribute
  • getStipplePattern() : LineAttribute
  • getStringAnnotationValue() : CgFxEffect
  • getStringParameterValue() : CgFxEffect
  • getStrips() : StrippedPrimitiveSet
  • getStructParameterMember() : CgFxEffect
  • getStructParameterMemberByName() : CgFxEffect
  • getSupportWidth() : Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter
  • getTail() : Path
  • getTargetDistance() : ViewState
  • getTechnique() : CgFxEffect
  • getTechniqueAnnotation() : CgFxEffect
  • getTechniqueAnnotationByName() : CgFxEffect
  • getTechniqueByName() : CgFxEffect
  • getTechniqueName() : CgFxEffect
  • getTexCoords() : VertexAttributeSet
  • getTexCoordsDim() : VertexAttributeSet
  • getTexGenLinearPlane() : TextureAttributeItem
  • getTexGenMode() : TextureAttributeItem
  • getTextureAttributeItem() : TextureAttribute
  • getTextureFileName() : TextureAttributeItem
  • getTextureImage() : TextureAttributeItem
  • getTextureSizeLimit() : RenderTraverser
  • getTrafo() : Transform
  • getTrafoAxisAligned() : Billboard
  • getTrafoScreenAligned() : Billboard
  • getTransform() : 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
  • getUnpackAlignment() : TextureImage
  • getUpVector() : Camera
  • getValue() : InterpolatedAnimation
  • getVariant() : StateSet
  • getVariantKey() : StateSet
  • getVertexAttributeData() : VertexAttributeSet
  • getVertexAttributeDataDim() : VertexAttributeSet
  • getVertexAttributeIndex() : NormalizeTraverser
  • getVertexAttributeSet() : PrimitiveSet
  • getVertexIndices() : Intersection
  • getVertexProgram() : CgFxEffect
  • getVertices() : VertexAttributeSet, HighlightBox
  • getViewportHeight() : RenderArea
  • getViewportWidth() : RenderArea
  • getViewState() : RenderArea
  • getViewToClip() : TransformStack
  • getViewToModel() : TransformStack
  • getViewToWorld() : TransformStack
  • getViewToWorldMatrix() : Camera
  • getVSensitivity() : FlightCameraManipulator
  • getWeight() : Bone
  • getWidth() : TextureImage, Map, LineAttribute
  • getWindowOffset() : Camera
  • getWindowRegion() : Camera
  • getWindowSize() : Camera
  • getWorldToModel() : TransformStack
  • getWorldToView() : TransformStack
  • getWorldToViewMatrix() : Camera
  • getWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • getWrapMode() : TextureAttributeItem
  • GLFunctions() : GLFunctions
  • GLMFCRAWnd() : GLMFCRAWnd
  • GLObjects() : GLObjects
  • GLTraverser() : GLTraverser
  • GLWinRenderArea() : GLWinRenderArea
  • gotoFrame() : AnimationManipulator
  • Group() : Group
  • GroupEliminateTraverser() : GroupEliminateTraverser

- h -

  • handleAnimatedQuads() : VertexUnifyTraverser, TriangulateTraverser, Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleAnimatedTransform() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleAnimatedTriangles() : VertexUnifyTraverser, Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleBillboard() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleBitmap() : Traverser, GLTraverser
  • handleBlendAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleCgFx() : Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleDepthAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleDirectedLight() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFaceAttribute() : Traverser, SearchTraverser, RayIntersectTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedTrafoAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleFramedVNVectorAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleGeoNode() : TriangulateTraverser, Traverser, StrippingTraverser, StateSetUnifyTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, DestrippingTraverser, CullTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleGroup() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RayIntersectTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleHighlightBox() : Traverser, AppTraverser
  • handleHighlightEdges() : Traverser
  • handleLinearInterpolatedTrafoAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLinearInterpolatedVNVectorAnimation() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLines() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLineStrips() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleLOD() : Traverser, SwitchToGroupTraverser, SearchTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleMapArray() : Traverser, RenderTraverser
  • handleMapElement() : Traverser, RenderTraverser
  • handleMapList() : Traverser, GLTraverser
  • handleMapMatrix() : Traverser, RenderTraverser
  • handleMaterial() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleParallelCamera() : Traverser, SearchTraverser, RenderTraverser, ModelViewTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePerspectiveCamera() : Traverser, SearchTraverser, RenderTraverser, ModelViewTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointAttribute() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePointLight() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handlePoints() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadMeshes() : Traverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuads() : TriangulateTraverser, Traverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleQuadStrips() : TriangulateTraverser, Traverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleShape() : Traverser, AnalyzeTraverser
  • handleSkinnedTriangles() : VertexUnifyTraverser, Traverser, SearchTraverser, RayIntersectTraverser, AppTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSpotLight() : Traverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStatePass() : Traverser, StateSetUnifyTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleStateSet() : Traverser, StateSetUnifyTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetCombineTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleStateVariant() : Traverser, StateSetUnifyTraverser, SearchTraverser, RenderTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleSwitch() : Traverser, SearchTraverser, RayIntersectTraverser, LODEliminateTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTextureAttribute() : Traverser, StateSetUnifyTraverser, SearchTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTextureAttributeItem() : Traverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTransform() : Traverser, TransformCombineTraverser, SwitchToGroupTraverser, SearchTraverser, RenderTraverser, RayIntersectTraverser, ModelViewTraverser, LODEliminateTraverser, LODCombineTraverser, IdentityToGroupTraverser, GroupEliminateTraverser, GeoNodeUnifyTraverser, GeoNodeCombineTraverser, CullTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, WRLLoadTraverser
  • handleTriangles() : Traverser, StrippingTraverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser, NVBLoadTraverser
  • handleTriFans() : Traverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleTriStrips() : Traverser, SmoothTraverser, SearchTraverser, RayIntersectTraverser, PrimitiveSetUnifyTraverser, PrimitiveSetCombineTraverser, GLTraverser, DestrippingTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • handleVertexAttributeSet() : VertexUnifyTraverser, Traverser, NormalizeTraverser, GLTraverser, AnalyzeTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • hasChild() : Group
  • hasFaces() : Triangles, Quads
  • hasIndices() : IndependentPrimitiveSet
  • hasMeshes() : MeshedPrimitiveSet
  • hasSegments() : Lines
  • hasStrips() : StrippedPrimitiveSet
  • hasTexCoords() : VertexAttributeSet
  • hiddenBegin() : RenderTraverser, GLTraverser
  • hiddenEnd() : RenderTraverser, GLTraverser
  • highlightBegin() : RenderTraverser, GLTraverser
  • HighlightBox() : HighlightBox
  • HighlightEdges() : HighlightEdges
  • highlightEnd() : RenderTraverser, GLTraverser
  • HighlightObject() : HighlightObject

- i -

  • IAllocator() : IAllocator
  • IdentityToGroupTraverser() : IdentityToGroupTraverser
  • Incarnation() : Incarnation
  • increaseIncarnation() : Object
  • incrementMipmapUseCount() : TextureImage
  • IndependentPrimitiveSet() : IndependentPrimitiveSet
  • init() : GLMFCRAWnd, Log, FixedAllocator, RenderArea, GLWinRenderArea
  • initGL() : GLWinRenderArea
  • insertEmptyColumn() : MapMatrix
  • insertMap() : MapMatrix, MapArray
  • insertMapObject() : MapList
  • instance() : Singleton
  • InterpolatedAnimation() : InterpolatedAnimation
  • interruptRender() : RenderArea
  • interruptTraversal() : Traverser
  • intersectingSphere() : Sphere3f
  • Intersection() : Intersection
  • intersectLine() : RayIntersectTraverser
  • intersectPoint() : RayIntersectTraverser
  • intersectTriangle() : RayIntersectTraverser
  • invalidate() : Sphere3f, HighlightObject
  • invalidateBoundingSphere() : Node, HighlightObject, Drawable
  • invalidateCaches() : Group, GeoNode
  • invalidateCgFxContainment() : StateVariant, StateSet, StatePass, Node, Group, GeoNode
  • invalidateHintsContainment() : Node
  • invalidateIncarnation() : VertexAttributeSet, TextureAttributeItem, StateVariant, StateSet, StatePass, StateAttribute, Object, Node, Drawable
  • invalidateLightContainment() : Node, Group
  • invalidateNumberOfFrames() : Node, Group, GeoNode, Drawable
  • invalidateTransparencyContainment() : StateVariant, StateSet, StatePass, StateAttribute, Node
  • invert() : Matnnf
  • is1D() : TextureImage
  • is2D() : TextureImage
  • is3D() : TextureImage
  • isActive() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator, 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
  • isCgFxAware() : RenderTraverser
  • isClipPlaneActive() : Group
  • isCompatible() : PrimitiveSet
  • isCritical() : NVSGException
  • isCubeMap() : TextureImage
  • isDataShared() : VertexAttributeSet, TextureAttributeItem, StrippedPrimitiveSet, SkinnedTriangles, Object, MeshedPrimitiveSet, Material, IndependentPrimitiveSet, CgFx
  • isDepthTestingEnabled() : DepthAttribute
  • isDepthWritingEnabled() : DepthAttribute
  • isDolly() : TrackballTransformManipulator, TrackballCameraManipulator
  • isEachPassTransparent() : StateVariant
  • isEmpty() : Sphere3f, Path
  • isEnabled() : Log
  • isEquivalent() : VertexAttributeSet, Transform, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, SpotLight, SkinnedTriangles, Shape, PrimitiveSet, PointLight, PointAttribute, Object, MeshedPrimitiveSet, Material, LOD, LineAttribute, LightSource, InterpolatedAnimation, IndependentPrimitiveSet, Group, GeoNode, FramedAnimation, FaceAttribute, DepthAttribute, CgFx, BlendAttribute, Billboard, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • isExported() : GLFunctions
  • isFaceCullingOverwrite() : RenderTraverser
  • isFaceModeOverwrite() : RenderTraverser
  • isFloatAnnotation() : CgFxEffect
  • isFloatingPoint() : TextureImage
  • isFloatParameter() : CgFxEffect
  • isFloatPassState() : CgFxEffect
  • isFloatSamplerState() : CgFxEffect
  • isFly() : FlightCameraManipulator
  • isFromFile() : CgFxEffect
  • isFromLump() : CgFxEffect
  • isFrontFaceCulling() : RenderTraverser, FaceAttribute
  • isGeometryCacheTechniqueSupported() : RenderTraverser, GLTraverser
  • isHWFSAAAvailable() : RenderArea
  • isHWFSAAEnabled() : GLWinRenderArea
  • isIdentity() : Matnnf
  • isImageStream() : TextureImage
  • isInputProgramParameter() : CgFxEffect
  • isInsideBounds() : Chunk
  • isIntAnnotation() : CgFxEffect
  • isIntParameter() : CgFxEffect
  • isIntPassState() : CgFxEffect
  • isIntSamplerState() : CgFxEffect
  • isJitter() : ViewState, NBFViewState
  • isJitterTechniqueSupported() : RenderTraverser, GLTraverser
  • isLightArrayParameter() : CgFxEffect
  • isLightParameter() : CgFxEffect
  • isLineAntiAliasingEnabled() : RenderTraverser
  • isLoadable() : TextureAttributeItem
  • isLocalViewerEnabled() : GLTraverser
  • isMaterialParameter() : CgFxEffect
  • isMatrix22Parameter() : CgFxEffect
  • isMatrix23Parameter() : CgFxEffect
  • isMatrix24Parameter() : CgFxEffect
  • isMatrix32Parameter() : CgFxEffect
  • isMatrix33Parameter() : CgFxEffect
  • isMatrix34Parameter() : CgFxEffect
  • isMatrix42Parameter() : CgFxEffect
  • isMatrix43Parameter() : CgFxEffect
  • isMatrix44Parameter() : CgFxEffect
  • isMipmapSamplerState() : CgFxEffect
  • isNormalized() : Vecnf, Quatf, Matnnf
  • isNull() : Vecnf, Quatf, Matnnf
  • isOcclusionCulling() : RenderTraverser
  • isOcclusionCullingSupported() : RenderTraverser, GLTraverser
  • isOITTechniqueSupported() : RenderTraverser, GLTraverser
  • isOrbit() : TrackballCameraManipulator
  • isOrthogonal() : Matnnf
  • isOutputProgramParameter() : CgFxEffect
  • isOverlayPass() : RenderTraverser
  • isPan() : TrackballTransformManipulator, TrackballCameraManipulator
  • isPointAntiAliasingEnabled() : RenderTraverser
  • isPolygonOffset() : FaceAttribute
  • isProgramCompiled() : CgFxEffect
  • isRangeLockEnabled() : LOD
  • isRenderTechniqueSupported() : RenderTraverser, GLTraverser
  • isRotate() : TrackballTransformManipulator
  • isRotation() : Mat33f
  • isSampler1DParameter() : CgFxEffect
  • isSampler2DParameter() : CgFxEffect
  • isSampler3DParameter() : CgFxEffect
  • isSamplerCubeParameter() : CgFxEffect
  • isSamplerParameter() : CgFxEffect
  • isSamplerRectParameter() : CgFxEffect
  • isScalarParameter() : CgFxEffect
  • isScreenAligned() : Billboard
  • isSeparateSpecularColorEnabled() : GLTraverser
  • isShadowCasting() : LightSource
  • isShadowTechniqueSupported() : RenderTraverser, GLTraverser
  • isShareable() : RCObject
  • isShared() : PointerReference, RCObject, NBFObject
  • isStereo() : ViewState, NBFViewState
  • isStereoAutomaticEyeDistanceAdjustment() : ViewState
  • isStereoAvailable() : RenderArea
  • isStereoReversedEyes() : ViewState
  • isStringAnnotation() : CgFxEffect
  • isStringParameter() : CgFxEffect
  • isStructParameter() : CgFxEffect
  • isTilt() : WalkCameraManipulator
  • isTransformParameter() : CgFxEffect
  • isTranslate() : WalkCameraManipulator
  • isTransparencyTechniqueSupported() : RenderTraverser, GLTraverser
  • isTransparent() : StateVariant, StateSet, StatePass, StateAttribute, CgFx, BlendAttribute
  • isTransparentPass() : RenderTraverser, CgFxEffect
  • isTwoSidedLighting() : FaceAttribute
  • isTwoSidedLightingOverwrite() : RenderTraverser
  • isTwoSidedLigthing() : RenderTraverser
  • isUnused() : Chunk
  • isUploadDemanded() : TextureImage
  • isValid() : HighlightObject, CgFxEffect
  • isVector2Parameter() : CgFxEffect
  • isVector3Parameter() : CgFxEffect
  • isVector4Parameter() : CgFxEffect
  • isWalk() : WalkCameraManipulator

- k -

  • keyDown() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator
  • KeyInput() : KeyInput
  • keyUp() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, KeyInput, FlightCameraManipulator

- l -

  • lastFrame() : AnimationManipulator
  • length() : Vecnf
  • lengthd() : Vecnf
  • lengthSquared() : Vecnf
  • lerp() : Trafo, Quatf
  • LightSource() : LightSource
  • LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • LineAttribute() : LineAttribute
  • Lines() : Lines
  • LineStrips() : LineStrips
  • load() : TextureLoader, SceneLoader, WRLLoader, NVSGLoader, NVNVB, NVBLoader, NBFLoader, ILTexLoader
  • loadCustomObject() : NBFLoader
  • Lockable() : Lockable
  • LOD() : LOD
  • LODCombineTraverser() : LODCombineTraverser
  • LODEliminateTraverser() : LODEliminateTraverser
  • Log() : Log

- m -

  • magnitude() : Quatf
  • makeCurrent() : GLWinRenderArea
  • Manipulator() : Manipulator
  • Map() : Map
  • MapArray() : MapArray
  • MapElement() : MapElement
  • MapList() : MapList
  • MapMatrix() : MapMatrix
  • MapObject() : MapObject
  • mapOffset() : NBFLoader
  • mapViewOfFile() : NBFSaveTraverser
  • markUnshareable() : RCObject
  • Mat33f() : Mat33f
  • Mat44f() : Mat44f
  • Material() : Material
  • Matnnf() : Matnnf
  • maxElement() : Vecnf
  • MemFunTbl() : MemFunTbl
  • MeshedPrimitiveSet() : MeshedPrimitiveSet
  • minElement() : Vecnf
  • mirrorX() : TextureImage
  • mirrorY() : TextureImage
  • ModelViewTraverser() : ModelViewTraverser
  • 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 -

  • n() : Plane3f
  • NBFSaver() : NBFSaver
  • NBFSaveTraverser() : NBFSaveTraverser
  • nearestPoint() : Plane3f
  • 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
  • normalize() : Vec3f, Vecnf, Quatf
  • NormalizeTraverser() : NormalizeTraverser
  • NVBImportError() : NVNVB
  • NVBLoadTraverser() : NVBLoadTraverser
  • NVBLog() : NVNVB
  • NVSGException() : NVSGException
  • NVSGSaveTraverser() : NVSGSaveTraverser

- o -

  • Object() : Object
  • Offset_AutoPtr() : Offset_AutoPtr
  • onEmptyToken() : PlugInCallback
  • OnEraseBkgnd() : GLMFCRAWnd
  • onError() : PlugInCallback
  • onFileAccessFailed() : PlugInCallback
  • onFileEmpty() : PlugInCallback
  • onFileMappingFailed() : PlugInCallback
  • onFileNotFound() : PlugInCallback
  • onFilesNotFound() : PlugInCallback
  • onImcompatibleFile() : PlugInCallback
  • onIncompatibleValues() : PlugInCallback
  • onInvalidFile() : PlugInCallback
  • onInvalidValue() : PlugInCallback
  • OnPaint() : GLMFCRAWnd
  • onReleaseDAL() : DALDataCreator
  • onUndefinedToken() : PlugInCallback
  • onUnexpectedEndOfFile() : PlugInCallback
  • onUnexpectedToken() : PlugInCallback
  • onUnknownToken() : PlugInCallback
  • onUnsupportedToken() : PlugInCallback
  • onWarning() : PlugInCallback
  • operator *() : Vecnf, Vec4f, Vec3f, Vec2f, Matnnf, Mat44f, PointerReference, RCObject_AutoPtr, RCIPtr, RCPtr, Lockable, Vecnf, Quatf, Matnnf, Offset_AutoPtr
  • operator *=() : Vecnf, Quatf, Matnnf
  • operator const T &() : RegVal
  • operator const T *() : Offset_AutoPtr
  • operator delete() : IAllocator
  • operator new() : IAllocator
  • operator T *() : PointerReference, Offset_AutoPtr
  • operator!=() : CullData, PointerReference, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VariantIterator, Vecnf, Sphere3f, Quatf, Plane3f, Matnnf
  • operator()() : TraceFunctor, traceFileConsoleOutput, traceFileDebugOutput, traceFileOutput, traceConsoleDebugOutput, traceConsoleOutput, traceDebugOutput, removeReference, addReference, Lanczos3Filter, BSplineFilter, BellFilter, TriangleFilter, BoxFilter, ScaleFilter, Bone, Sphere3f, Plane3f
  • operator+() : Incarnation, Vecnf, Matnnf
  • operator++() : Incarnation
  • operator+=() : Vecnf, Matnnf
  • operator-() : Vecnf, Vec3f, Quatf, Plane3f, Matnnf
  • operator-=() : Vecnf, Matnnf
  • operator->() : PointerReference, RCObject_AutoPtr, RCIPtr, RCPtr, Lockable, Offset_AutoPtr
  • operator/() : Vecnf, Quatf, Matnnf
  • operator/=() : Vecnf, Quatf, Matnnf
  • operator=() : RegVal, RCObject_AutoPtr, RCIPtr, RCPtr, RCObject, UPIID, MouseInput, KeyInput, Intersection, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Bone, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, PrimitiveAttribute, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Object, Node, MeshedPrimitiveSet, Material, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, InterpolatedAnimation, IndependentPrimitiveSet, HighlightObject, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Billboard, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads, Vecnf, Vec3f, Trafo, Sphere3f, Quatf, Plane3f, Matnnf
  • operator==() : CullData, PointerReference, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VNVector, VariantIterator, Bone, Vecnf, Trafo, Sphere3f, Quatf, Plane3f, Matnnf
  • operator[]() : MemFunTbl, LinearInterpolatedAnimation, FramedAnimation, Face, Animation, Vecnf, Quatf, Matnnf
  • operator^() : Vec3f
  • operator~() : Quatf, Matnnf
  • OptimizeTraverser() : OptimizeTraverser
  • orbit() : Camera
  • orbitX() : Camera
  • orbitY() : Camera
  • orbitZ() : Camera
  • orthogonalize() : Vecnf
  • orthonormalize() : Vecnf
  • overlayBegin() : RenderTraverser, GLTraverser
  • overlayEnd() : RenderTraverser, GLTraverser

- p -

  • PADDING() : NBFPointAttribute, NBFLineAttribute, NBFFaceAttribute, NBFDepthAttribute, NBFCgFx, NBFBlendAttribute, NBFStateSet, NBFSpotLight, NBFDirectedLight, NBFLightSource, NBFAnimatedTransform, NBFTransform, NBFBillboard, NBFLOD, NBFNode, NBFAnimatedIndependents, NBFPrimitiveSet, NBFCamera, NBFFramedVNVectorAnimation, NBFFramedTrafoAnimation, NBFTrafoAnimation, NBFObject, NBFViewState, NBFHeader
  • ParallelCamera() : ParallelCamera
  • Path() : Path
  • PerspectiveCamera() : PerspectiveCamera
  • pickCameraTargetPoint() : RenderArea
  • pickMap() : MapObject, MapMatrix, MapList, MapElement, MapArray
  • Plane3f() : Plane3f
  • PlugInCallback() : PlugInCallback
  • PointAttribute() : PointAttribute
  • PointerReference() : PointerReference
  • PointLight() : PointLight
  • Points() : Points
  • pop() : Path
  • popCullTraverser() : RenderArea
  • popModelToWorld() : TransformStack
  • postAddChild() : Switch, Group
  • postApply() : Traverser
  • postRemoveChild() : Switch, Group
  • postTraverseDrawable() : Traverser
  • postTraverseDrawables() : Traverser, RenderTraverser
  • postTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser, AnalyzeTraverser
  • postTraverseMap() : Traverser
  • postTraverseMapColumn() : Traverser, RenderTraverser
  • postTraverseRoot() : Traverser
  • postTraverseTransform() : RenderTraverser, RayIntersectTraverser, ModelViewTraverser, FrustumCullTraverser
  • preAddChild() : Group
  • preApply() : Traverser
  • preCalculateFileSize() : NBFSaveTraverser
  • PreCreateWindow() : GLMFCRAWnd
  • preRemoveChild() : Group
  • preTraverseDrawable() : Traverser
  • preTraverseDrawables() : Traverser, RenderTraverser
  • preTraverseGroup() : Traverser, RenderTraverser, RayIntersectTraverser, AnalyzeTraverser
  • preTraverseMap() : Traverser, RenderTraverser
  • preTraverseMapColumn() : Traverser, RenderTraverser
  • preTraverseRoot() : Traverser, ModelViewTraverser, FrustumCullTraverser
  • preTraverseTransform() : RenderTraverser, RayIntersectTraverser, ModelViewTraverser, FrustumCullTraverser
  • previousFrame() : AnimationManipulator
  • PrimitiveAttribute() : PrimitiveAttribute
  • PrimitiveSet() : PrimitiveSet
  • PrimitiveSetCombineTraverser() : PrimitiveSetCombineTraverser
  • primitiveSetsBegin() : RenderTraverser, GLTraverser
  • primitiveSetsEnd() : RenderTraverser, GLTraverser
  • PrimitiveSetUnifyTraverser() : PrimitiveSetUnifyTraverser
  • ProblemInfo() : ProblemInfo
  • projectOntoTBSphere() : Trackball
  • pseudoAlloc() : NBFSaveTraverser
  • push() : Path
  • pushCullTraverser() : RenderArea
  • pushModelToWorld() : TransformStack

- q -

  • QuadMeshes() : QuadMeshes
  • Quads() : Quads
  • QuadStrips() : QuadStrips
  • Quatf() : Quatf

- r -

  • RayIntersectTraverser() : RayIntersectTraverser
  • RayIntersectTraverser::getWorldIntersection() : RayIntersectTraverser
  • RCIPtr() : RCIPtr
  • RCObject() : RCObject
  • RCObject_AutoPtr() : RCObject_AutoPtr
  • RCPtr() : RCPtr
  • RCVector() : RCVector
  • RegVal() : RegVal
  • release() : RCObject_AutoPtr, RayIntersectTraverser
  • releaseDeviceAbstractionLinkData() : DALDataCreator, DALHost
  • releaseImages() : TextureImage
  • reloadSamplerTextureImage() : CgFxEffect
  • reloadTextureImage() : TextureAttributeItem
  • removeAttribute() : StateVariant, StateSet, StatePass
  • removeAttributeByObjectCode() : StateVariant, StateSet, StatePass
  • removeBuffers() : GLObjects
  • removeCamera() : Scene
  • removeCameraAnimation() : Scene
  • removeChild() : Group
  • removeColumn() : MapMatrix
  • removeGeometry() : GeoNode
  • removeHeadLight() : Camera
  • removeHints() : Node
  • removeLists() : GLObjects
  • removeMap() : MapMatrix, MapArray
  • removeMapObject() : MapList
  • removeOcclusionQueries() : GLObjects
  • removeOnDestroyCallback() : RCObject
  • removePass() : StateVariant, StateSet
  • removePrimitiveSet() : Shape
  • removePrograms() : GLObjects
  • removeQueries() : GLObjects
  • removeRef() : PointerReference, RCObject
  • removeTextures() : GLObjects
  • removeVariant() : StateSet
  • renderAnimatedQuads() : RenderTraverser, GLTraverser
  • renderAnimatedTriangles() : RenderTraverser, GLTraverser
  • RenderArea() : RenderArea
  • renderBegin() : RenderTraverser, GLTraverser
  • renderBlendAttribute() : RenderTraverser, GLTraverser
  • renderCgFx() : RenderTraverser
  • renderDepthAttribute() : RenderTraverser, GLTraverser
  • renderDirectedLight() : RenderTraverser, GLTraverser
  • renderEnd() : RenderTraverser, GLTraverser
  • renderFaceAttribute() : RenderTraverser, GLTraverser
  • renderHighlightBox() : RenderTraverser, GLTraverser
  • renderHighlightEdges() : 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
  • RenderTraverser() : RenderTraverser
  • renderTriangles() : RenderTraverser, GLTraverser
  • renderTriFans() : RenderTraverser, GLTraverser
  • renderTriStrips() : RenderTraverser, GLTraverser
  • replaceChild() : Group
  • replaceDrawable() : GeoNode
  • replaceMap() : MapMatrix, MapArray
  • replaceMapObject() : MapList
  • replacePass() : StateVariant, StateSet
  • replaceStateSet() : GeoNode
  • replaceVariant() : StateSet
  • replaceVariantKey() : StateSet
  • requestHWFSAA() : RenderArea
  • requestStereoSupport() : RenderArea
  • reset() : RCObject_AutoPtr, Lockable, WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator, Offset_AutoPtr
  • resetButtonState() : MouseInput
  • resetKeyState() : KeyInput
  • resetLightValues() : CgFxEffect
  • resetMaterialValues() : CgFxEffect
  • resetPass() : CgFxEffect
  • resetPositions() : MouseInput
  • rotate() : Camera
  • rotateX() : Camera
  • rotateY() : Camera
  • rotateZ() : Camera

- s -

  • save() : SceneSaver, NVSGSaver, NBFSaver
  • scale() : TextureImage
  • Scene() : Scene
  • search() : SearchTraverser
  • SearchTraverser() : SearchTraverser
  • set() : Vec4f, Vec3f, Vec2f, Mat44f, Mat33f
  • setActive() : Switch
  • setActiveVariantKey() : StateSet
  • setAlignment() : MapMatrix, MapArray
  • setAmbientColor() : Scene, Material, LightSource
  • setAnimation() : ViewState, Bone, LightSource, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • setAnimationFrame() : ViewState, SkinnedTriangles, LightSource, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • setAnnotation() : Node
  • setAntiAliasing() : PointAttribute, LineAttribute
  • setAppTraverser() : RenderArea
  • setAspectRatio() : Camera
  • setAttenuation() : SpotLight, PointLight
  • setAutoClipPlanes() : Camera
  • setBackColor() : Scene
  • setBaseClassSearch() : SearchTraverser
  • setBlendFunctions() : BlendAttribute
  • setBoolParameterValue() : CgFxEffect
  • setBorderColor() : TextureAttributeItem
  • setCallback() : PlugIn
  • setCamClipping() : RayIntersectTraverser
  • setCamera() : ViewState
  • setCameraAnimation() : AnimationManipulator
  • setCenter() : LOD, Trafo, Sphere3f
  • setCgFxAwareness() : RenderTraverser
  • setClassName() : SearchTraverser
  • setClipPlane() : RenderTraverser, GLTraverser, Group
  • setColor() : HighlightEdges, HighlightBox, Bitmap
  • setColors() : VertexAttributeSet
  • setCreaseAngle() : SmoothTraverser
  • setCullMode() : FaceAttribute
  • setCullTree() : ViewState
  • setCurrent() : InterpolatedAnimation
  • setCurrentTechnique() : CgFxEffect
  • setCutoffAngle() : SpotLight
  • setDepthFunction() : DepthAttribute
  • setDepthTestingEnabled() : DepthAttribute
  • setDepthWritingEnabled() : DepthAttribute
  • setDiffuseColor() : Material, LightSource
  • setDirection() : SpotLight, DirectedLight, Camera
  • setEmissiveColor() : Material
  • setEnvColor() : TextureAttributeItem
  • setEnvMode() : TextureAttributeItem
  • setEpsilon() : VertexUnifyTraverser
  • setFaceCulling() : RenderTraverser
  • setFaceCullingOverwrite() : RenderTraverser
  • setFaceMode() : RenderTraverser, FaceAttribute
  • setFaceModeOverwrite() : RenderTraverser
  • setFaces() : Triangles, Quads
  • setFalloffExponent() : SpotLight
  • setFarDistance() : Camera
  • setFieldOfView() : PerspectiveCamera
  • setFILE() : NVSGSaveTraverser
  • setFloatParameterValue() : CgFxEffect
  • setFocusDistance() : PerspectiveCamera, Camera
  • setFogCoords() : VertexAttributeSet
  • setGeometryCacheTechnique() : RenderTraverser, GLTraverser
  • setHints() : Node
  • setHSensitivity() : WalkCameraManipulator, FlightCameraManipulator
  • setIdentity() : Matnnf, Trafo
  • setIgnoreNames() : OptimizeTraverser
  • setIgnoreShares() : PrimitiveSetCombineTraverser
  • setInactive() : Switch
  • setIndices() : IndependentPrimitiveSet
  • setIntensity() : LightSource
  • setIntParameterValue() : CgFxEffect
  • setInverse() : Bone
  • setJitter() : ViewState
  • setJitterTechnique() : RenderTraverser, GLTraverser
  • setKeyFrame() : InterpolatedAnimation
  • 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
  • setMapList() : ViewState
  • setMaterialAmbientValue() : CgFxEffect
  • setMaterialDiffuseValue() : CgFxEffect
  • setMaterialEmissionValue() : CgFxEffect
  • setMaterialShininessValue() : CgFxEffect
  • setMaterialSpecularValue() : CgFxEffect
  • setMatrix() : Bone, Trafo
  • setMaxNumberOfVertices() : PrimitiveSetCombineTraverser
  • setMeshes() : MeshedPrimitiveSet
  • setMinFilterMode() : TextureAttributeItem
  • setMinimalLengths() : StrippingTraverser
  • setName() : Object
  • setNearDistance() : Camera
  • setNormals() : VertexAttributeSet
  • setNumberOfFrames() : AnimationManipulator, FramedAnimation
  • setNumberOfKeys() : InterpolatedAnimation
  • setOcclusionCulling() : RenderTraverser
  • setOITMaxPasses() : RenderTraverser, GLTraverser
  • setOITTechnique() : RenderTraverser, GLTraverser
  • setOITThreshold() : RenderTraverser
  • setOpacity() : Material
  • setOrientation() : TextureAttributeItem, SpotLight, MapArray, DirectedLight, Camera, Trafo
  • setParameterValueAsFloat() : CgFxEffect
  • setPointAntiAliasing() : RenderTraverser
  • setPointSize() : RenderTraverser
  • setPolygonOffset() : FaceAttribute
  • setPosition() : SpotLight, PointLight, MapObject, Camera
  • setProgramProfile() : CgFxEffect
  • setRadius() : Sphere3f
  • setRangeLock() : LOD
  • setRanges() : LOD
  • setRay() : RayIntersectTraverser
  • setRelation() : MapObject
  • setRenderArea() : Manipulator
  • setRenderTechnique() : RenderTraverser
  • setRenderTraverser() : RenderArea
  • setRootNode() : Scene
  • setRotationAxis() : Billboard
  • setSamplerTextureImageSpec() : CgFxEffect
  • setScaleOrientation() : Trafo
  • setScaling() : TextureAttributeItem, Trafo
  • setScene() : RenderArea
  • setSceneData() : RenderArea
  • setScreenAligned() : Billboard
  • setScreenSize() : WalkCameraManipulator
  • setSecondaryColors() : VertexAttributeSet
  • setSegments() : Lines
  • setSeparateSpecularColor() : GLTraverser
  • setShadowCasting() : LightSource
  • setShadowMapIntensity() : RenderTraverser
  • setShadowMapSize() : RenderTraverser, GLTraverser
  • setShadowTechnique() : RenderTraverser, GLTraverser
  • setSize() : Trackball, PointAttribute
  • setSkins() : SkinnedTriangles
  • setSortingPolicy() : RenderTraverser
  • setSpacing() : MapMatrix, MapArray
  • setSpecularColor() : Material, LightSource
  • setSpecularExponent() : Material
  • setSpeed() : WalkCameraManipulator, FlightCameraManipulator
  • setSpeedIncreaseFactor() : WalkCameraManipulator, FlightCameraManipulator
  • setStereo() : ViewState
  • setStereoAutomaticEyeDistanceAdjustment() : ViewState
  • setStereoAutomaticEyeDistanceFactor() : ViewState
  • setStereoEyeDistance() : ViewState
  • setStippleFactor() : LineAttribute
  • setStipplePattern() : LineAttribute
  • setStringParameterValue() : CgFxEffect
  • setStrips() : StrippedPrimitiveSet
  • setTargetDistance() : ViewState
  • setTexCoords() : VertexAttributeSet
  • setTexGenLinearPlane() : TextureAttributeItem
  • setTexGenMode() : TextureAttributeItem
  • setTextureImageSpec() : TextureAttributeItem
  • setTextureSizeLimit() : RenderTraverser, GLTraverser
  • 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
  • setUpVector() : Camera
  • setVertexAttributeData() : VertexAttributeSet
  • setVertexAttributeIndex() : NormalizeTraverser
  • setVertexAttributeSet() : PrimitiveSet
  • setVertices() : VertexAttributeSet
  • setViewportSize() : GLMFCRAWnd, RenderArea, GLWinRenderArea, RayIntersectTraverser
  • setViewState() : RenderArea, ModelViewTraverser, NVSGSaveTraverser, NBFSaveTraverser
  • setViewToClip() : TransformStack
  • setVSensitivity() : FlightCameraManipulator
  • setWeight() : Bone
  • setWidth() : LineAttribute
  • setWindowOffset() : Camera
  • setWindowRegion() : Camera
  • setWindowSize() : Camera
  • setWorldToView() : TransformStack
  • setWorldUpVector() : WalkCameraManipulator, FlightCameraManipulator
  • setWrapMode() : TextureAttributeItem
  • Shape() : Shape
  • shareLists() : GLWinRenderArea
  • signedDistance() : Plane3f
  • SkinnedTriangles() : SkinnedTriangles
  • smoothNormals() : Vec3f
  • SmoothTraverser() : SmoothTraverser
  • Sphere3f() : Sphere3f
  • SpotLight() : SpotLight
  • StateAttribute() : StateAttribute
  • StatePass() : StatePass
  • StateSet() : StateSet
  • StateSetUnifyTraverser() : StateSetUnifyTraverser
  • StateVariant() : StateVariant
  • stereoReverseEyes() : ViewState
  • storeDeviceAbstractionLinkData() : DALHost
  • storeIntersection() : RayIntersectTraverser
  • StrippedPrimitiveSet() : StrippedPrimitiveSet
  • StrippingTraverser() : StrippingTraverser
  • Switch() : Switch
  • SwitchToGroupTraverser() : SwitchToGroupTraverser

- t -

  • testEntry() : MemFunTbl
  • TextureAttribute() : TextureAttribute
  • TextureAttributeItem() : TextureAttributeItem
  • TextureAttributeItemData() : TextureAttributeItemData
  • TextureImage() : TextureImage
  • toggleStereo() : ViewState
  • Trace() : Trace
  • Trackball() : Trackball
  • TrackballCameraManipulator() : TrackballCameraManipulator
  • TrackballTransformManipulator() : TrackballTransformManipulator
  • Trafo() : Trafo
  • Transform() : Transform
  • TransformCombineTraverser() : TransformCombineTraverser
  • TransformManipulator() : TransformManipulator
  • TransformStack() : TransformStack
  • transparentBegin() : RenderTraverser, GLTraverser
  • transparentEnd() : RenderTraverser, GLTraverser
  • traverseHighlightObject() : Traverser
  • traverseLight() : Traverser, RenderTraverser, CullTraverser, AppTraverser
  • traverseObject() : Traverser
  • traversePrimitiveSet() : VertexAttributeSetUnifyTraverser, Traverser, RenderTraverser, CullTraverser
  • Traverser() : Traverser
  • Triangles() : Triangles
  • TriangulateTraverser() : TriangulateTraverser
  • TriFans() : TriFans
  • triggerRedraw() : GLMFCRAWnd, RenderArea, GLWinRenderArea
  • TriStrips() : TriStrips
  • truncate() : Path

- u -

  • unbindTextureAttributeItem() : TextureAttribute
  • unloadPrograms() : CgFx
  • unmapOffset() : NBFLoader
  • unmapViewOfFile() : NBFSaveTraverser
  • updateFrame() : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, Manipulator, FlightCameraManipulator, AnimationManipulator
  • UPIID() : UPIID
  • UPITID() : UPITID

- v -

  • validate() : HighlightObject, HighlightBox
  • validateCurrentTechnique() : CgFxEffect
  • validateIncarnation() : TextureAttribute, StateVariant, StateSet, StatePass, SkinnedTriangles, Shape, PrimitiveSet, Object, MapMatrix, MapList, MapElement, MapArray, LightSource, Group, GeoNode, Drawable, Camera, AnimatedTriangles, AnimatedTransform, AnimatedQuads
  • Vec2f() : Vec2f
  • Vec3f() : Vec3f
  • Vec4f() : Vec4f
  • Vecnf() : Vecnf
  • VertexAttributeSet() : VertexAttributeSet
  • VertexAttributeSetUnifyTraverser() : VertexAttributeSetUnifyTraverser
  • VertexUnifyTraverser() : VertexUnifyTraverser
  • ViewState() : ViewState

- w -

  • waitToRead() : ISWMRSync
  • waitToWrite() : ISWMRSync
  • WalkCameraManipulator() : WalkCameraManipulator
  • wasRenderInterrupted() : RenderArea
  • wasTraversalInterrupted() : Traverser
  • WRLLoadTraverser() : WRLLoadTraverser

- z -

  • zoom() : Camera

- ~ -

  • ~Allocator() : Allocator
  • ~AnalyzeResult() : AnalyzeResult
  • ~AnalyzeTraverser() : AnalyzeTraverser
  • ~AnimatedQuads() : AnimatedQuads
  • ~AnimatedTransform() : AnimatedTransform
  • ~AnimatedTriangles() : AnimatedTriangles
  • ~Animation() : Animation
  • ~AnimationManipulator() : AnimationManipulator
  • ~AppTraverser() : AppTraverser
  • ~Billboard() : Billboard
  • ~Bitmap() : Bitmap
  • ~BlendAttribute() : BlendAttribute
  • ~Bone() : Bone
  • ~Camera() : Camera
  • ~CgFx() : CgFx
  • ~CullData() : CullData
  • ~CullTraverser() : CullTraverser
  • ~DepthAttribute() : DepthAttribute
  • ~DestrippingTraverser() : DestrippingTraverser
  • ~DirectedLight() : DirectedLight
  • ~Drawable() : Drawable
  • ~EmptyResult() : EmptyResult
  • ~EquivalenceResult() : EquivalenceResult
  • ~FaceAttribute() : FaceAttribute
  • ~FixedAllocator() : FixedAllocator
  • ~FlightCameraManipulator() : FlightCameraManipulator
  • ~FramedAnimation() : FramedAnimation
  • ~FrustumCullTraverser() : FrustumCullTraverser
  • ~GeoNode() : GeoNode
  • ~GeoNodeCombineTraverser() : GeoNodeCombineTraverser
  • ~GeoNodeUnifyTraverser() : GeoNodeUnifyTraverser
  • ~GLFunctions() : GLFunctions
  • ~GLMFCRAWnd() : GLMFCRAWnd
  • ~GLObjects() : GLObjects
  • ~GLTraverser() : GLTraverser
  • ~GLWinRenderArea() : GLWinRenderArea
  • ~Group() : Group
  • ~GroupEliminateTraverser() : GroupEliminateTraverser
  • ~HighlightEdges() : HighlightEdges
  • ~HighlightObject() : HighlightObject
  • ~IAllocator() : IAllocator
  • ~IdentityResult() : IdentityResult
  • ~IdentityToGroupTraverser() : IdentityToGroupTraverser
  • ~ILTexLoader() : ILTexLoader
  • ~IndependentPrimitiveSet() : IndependentPrimitiveSet
  • ~InterpolatedAnimation() : InterpolatedAnimation
  • ~Intersection() : Intersection
  • ~KeyInput() : KeyInput
  • ~LightSource() : LightSource
  • ~LinearInterpolatedAnimation() : LinearInterpolatedAnimation
  • ~LineAttribute() : LineAttribute
  • ~Lines() : Lines
  • ~LineStrips() : LineStrips
  • ~Lockable() : Lockable
  • ~LOD() : LOD
  • ~LODCombineTraverser() : LODCombineTraverser
  • ~LODEliminateTraverser() : LODEliminateTraverser
  • ~Manipulator() : Manipulator
  • ~Map() : Map
  • ~MapArray() : MapArray
  • ~MapElement() : MapElement
  • ~MapList() : MapList
  • ~MapMatrix() : MapMatrix
  • ~MapObject() : MapObject
  • ~Material() : Material
  • ~MeshedPrimitiveSet() : MeshedPrimitiveSet
  • ~MissingResult() : MissingResult
  • ~ModelViewTraverser() : ModelViewTraverser
  • ~MouseInput() : MouseInput
  • ~NBFLoader() : NBFLoader
  • ~Node() : Node
  • ~NormalizeTraverser() : NormalizeTraverser
  • ~NVBLoader() : NVBLoader
  • ~NVBLoadTraverser() : NVBLoadTraverser
  • ~Object() : Object
  • ~Offset_AutoPtr() : Offset_AutoPtr
  • ~OptimizeTraverser() : OptimizeTraverser
  • ~ParallelCamera() : ParallelCamera
  • ~Path() : Path
  • ~PerspectiveCamera() : PerspectiveCamera
  • ~PlugInCallback() : PlugInCallback
  • ~PointAttribute() : PointAttribute
  • ~PointLight() : PointLight
  • ~Points() : Points
  • ~PrimitiveAttribute() : PrimitiveAttribute
  • ~PrimitiveSet() : PrimitiveSet
  • ~PrimitiveSetCombineTraverser() : PrimitiveSetCombineTraverser
  • ~PrimitiveSetUnifyTraverser() : PrimitiveSetUnifyTraverser
  • ~QuadMeshes() : QuadMeshes
  • ~Quads() : Quads
  • ~QuadStrips() : QuadStrips
  • ~RayIntersectTraverser() : RayIntersectTraverser
  • ~RCIPtr() : RCIPtr
  • ~RCObject() : RCObject
  • ~RCObject_AutoPtr() : RCObject_AutoPtr
  • ~RCPtr() : RCPtr
  • ~RegVal() : RegVal
  • ~RenderArea() : RenderArea
  • ~RenderTraverser() : RenderTraverser
  • ~Scene() : Scene
  • ~SceneLoader() : SceneLoader
  • ~SceneSaver() : SceneSaver
  • ~SearchTraverser() : SearchTraverser
  • ~Shape() : Shape
  • ~SingleChildResult() : SingleChildResult
  • ~SkinnedTriangles() : SkinnedTriangles
  • ~SmoothTraverser() : SmoothTraverser
  • ~SpotLight() : SpotLight
  • ~StateAttribute() : StateAttribute
  • ~StatePass() : StatePass
  • ~StateSet() : StateSet
  • ~StateSetUnifyTraverser() : StateSetUnifyTraverser
  • ~StateVariant() : StateVariant
  • ~StrippedPrimitiveSet() : StrippedPrimitiveSet
  • ~StrippingTraverser() : StrippingTraverser
  • ~Switch() : Switch
  • ~SwitchToGroupTraverser() : SwitchToGroupTraverser
  • ~TextureAttribute() : TextureAttribute
  • ~TextureAttributeItem() : TextureAttributeItem
  • ~TextureLoader() : TextureLoader
  • ~Trace() : Trace
  • ~Trackball() : Trackball
  • ~TrackballCameraManipulator() : TrackballCameraManipulator
  • ~TrackballTransformManipulator() : TrackballTransformManipulator
  • ~Transform() : Transform
  • ~TransformCombineTraverser() : TransformCombineTraverser
  • ~TransformManipulator() : TransformManipulator
  • ~Traverser() : Traverser
  • ~Triangles() : Triangles
  • ~TriangulateTraverser() : TriangulateTraverser
  • ~TriFans() : TriFans
  • ~TriStrips() : TriStrips
  • ~VertexAttributeSet() : VertexAttributeSet
  • ~VertexAttributeSetUnifyTraverser() : VertexAttributeSetUnifyTraverser
  • ~VertexUnifyTraverser() : VertexUnifyTraverser
  • ~ViewState() : ViewState
  • ~WalkCameraManipulator() : WalkCameraManipulator
  • ~WRLLoadTraverser() : WRLLoadTraverser
Generated on Fri Aug 4 08:36:30 2006 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
a | b | c | d | g | i | l | m | n | o | q | r | s | w

- a -

  • addPlugInSearchPath : PlugInServer
  • areCollinear() : Vec3f
  • areOnOppositeSides() : Plane3f
  • areOnSameSide() : Plane3f
  • areOpposite() : Vecnf
  • areOrthogonal() : Vecnf
  • areOrthonormal() : Vecnf
  • areSimilar() : Vecnf

- b -

  • boundingSphere() : Sphere3f

- c -

  • calculateTangentSpace() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • clone() : CullData, Intersection, ViewState, VertexAttributeSet, TriStrips, TriFans, Triangles, Transform, TextureImage, TextureAttribute, TextureAttributeItem, Switch, StrippedPrimitiveSet, StateVariant, StateSet, StatePass, StateAttribute, SpotLight, SkinnedTriangles, Shape, QuadStrips, Quads, QuadMeshes, PrimitiveSet, Points, PointLight, PointAttribute, PerspectiveCamera, ParallelCamera, Node, MeshedPrimitiveSet, Material, MapObject, MapMatrix, MapList, MapElement, MapArray, Map, LOD, LineStrips, Lines, LineAttribute, LinearInterpolatedAnimation, LightSource, IndependentPrimitiveSet, HighlightEdges, HighlightBox, Group, GeoNode, FramedAnimation, FaceAttribute, Drawable, DirectedLight, DepthAttribute, CgFx, Camera, BlendAttribute, Bitmap, Billboard, Animation, AnimatedTriangles, AnimatedTransform, AnimatedQuads

- d -

  • decompose() : Quatf, Mat44f, Mat33f
  • determinant() : Mat33f
  • distance() : Vecnf, Quatf, Plane3f

- g -

  • generateNormals() : TriStrips, TriFans, Triangles, QuadStrips, Quads, QuadMeshes, GeoNode
  • generateTexCoords() : VertexAttributeSet, GeoNode
  • getInterface : PlugInServer
  • getPlugInSearchPath : PlugInServer
  • getPlugInterface : ILTexLoader
  • GLAccum : GLContext
  • GLActiveTexture : GLContext
  • GLAlphaFunc : GLContext
  • GLAreTexturesResident : GLContext
  • GLArrayElement : GLContext
  • GLBegin : GLContext
  • GLBeginOcclusionQuery : GLContext
  • GLBeginQuery : GLContext
  • GLBindBuffer : GLContext
  • GLBindProgram : GLContext
  • GLBindTexture : GLContext
  • GLBitmap : GLContext
  • GLBlendFunc : GLContext
  • GLBlendFuncSeparate : GLContext
  • GLBufferData : GLContext
  • GLBufferSubData : GLContext
  • GLCallList : GLContext
  • GLCallLists : GLContext
  • GLClear : GLContext
  • GLClearAccum : GLContext
  • GLClearColor : GLContext
  • GLClearDepth : GLContext
  • GLClearIndex : GLContext
  • GLClearStencil : GLContext
  • GLClientActiveTexture : GLContext
  • GLClipPlane : GLContext
  • GLColor3b : GLContext
  • GLColor3bv : GLContext
  • GLColor3d : GLContext
  • GLColor3dv : GLContext
  • GLColor3f : GLContext
  • GLColor3fv : 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
  • GLColor4i : GLContext
  • GLColor4iv : GLContext
  • GLColor4s : GLContext
  • GLColor4sv : GLContext
  • GLColor4ub : GLContext
  • GLColor4ubv : GLContext
  • GLColor4ui : GLContext
  • GLColor4uiv : GLContext
  • GLColor4us : GLContext
  • GLColor4usv : GLContext
  • GLColorMask : GLContext
  • GLColorMaterial : GLContext
  • GLColorPointer : GLContext
  • GLCompressedTexImage1D : GLContext
  • GLCompressedTexImage2D : GLContext
  • GLCompressedTexImage3D : GLContext
  • GLCopyPixels : GLContext
  • GLCopyTexImage1D : GLContext
  • GLCopyTexImage2D : GLContext
  • GLCopyTexSubImage1D : GLContext
  • GLCopyTexSubImage2D : GLContext
  • GLCullFace : GLContext
  • GLDeleteBuffers : GLContext
  • GLDeleteLists : GLContext
  • GLDeleteOcclusionQueries : GLContext
  • GLDeletePrograms : GLContext
  • GLDeleteQueries : GLContext
  • GLDeleteTextures : GLContext
  • GLDepthFunc : GLContext
  • GLDepthMask : GLContext
  • GLDepthRange : GLContext
  • GLDisable : GLContext
  • GLDisableBlend : GLContext
  • GLDisableClientState : GLContext
  • GLDisableColorArray : GLContext
  • GLDisableColorMaterial : GLContext
  • GLDisableCullFace : GLContext
  • GLDisableDepthTest : GLContext
  • GLDisableFogCoordinateArray : GLContext
  • GLDisableLighting : GLContext
  • GLDisableLineSmooth : GLContext
  • GLDisableLineStipple : GLContext
  • GLDisableNormalArray : GLContext
  • GLDisableNormalize : GLContext
  • GLDisablePointSmooth : GLContext
  • GLDisablePolygonOffsetFill : GLContext
  • GLDisablePolygonOffsetLine : GLContext
  • GLDisablePolygonOffsetPoint : GLContext
  • GLDisablePolygonStipple : GLContext
  • GLDisableSecondaryColorArray : GLContext
  • GLDisableTexture : GLContext
  • GLDisableTextureCoordArray : GLContext
  • GLDisableTextureGen : GLContext
  • GLDisableVertexArray : GLContext
  • GLDrawArrays : GLContext
  • GLDrawBuffer : GLContext
  • GLDrawElements : GLContext
  • GLDrawPixels : GLContext
  • GLDrawRangeElements : GLContext
  • GLEdgeFlag : GLContext
  • GLEdgeFlagPointer : GLContext
  • GLEdgeFlagv : GLContext
  • GLEnable : GLContext
  • GLEnableBlend : GLContext
  • GLEnableClientState : GLContext
  • GLEnableColorArray : GLContext
  • GLEnableColorMaterial : GLContext
  • GLEnableCullFace : GLContext
  • GLEnableDepthTest : GLContext
  • GLEnableFogCoordinateArray : GLContext
  • GLEnableLighting : GLContext
  • GLEnableLineSmooth : GLContext
  • GLEnableLineStipple : GLContext
  • GLEnableNormalArray : GLContext
  • GLEnableNormalize : GLContext
  • GLEnablePointSmooth : GLContext
  • GLEnablePolygonOffsetFill : GLContext
  • GLEnablePolygonOffsetLine : GLContext
  • GLEnablePolygonOffsetPoint : GLContext
  • GLEnablePolygonStipple : GLContext
  • GLEnableSecondaryColorArray : GLContext
  • GLEnableTexture : GLContext
  • GLEnableTextureCoordArray : GLContext
  • GLEnableTextureGen : GLContext
  • GLEnableVertexArray : GLContext
  • GLEnd : GLContext
  • GLEndList : GLContext
  • GLEndOcclusionQuery : GLContext
  • GLEndQuery : GLContext
  • GLEvalCoord1d : GLContext
  • GLEvalCoord1f : GLContext
  • GLEvalCoord2d : GLContext
  • GLEvalCoord2f : GLContext
  • GLEvalMesh1 : GLContext
  • GLEvalMesh2 : GLContext
  • GLEvalPoint1 : GLContext
  • GLEvalPoint2 : GLContext
  • GLFeedbackBuffer : GLContext
  • GLFinish : GLContext
  • GLFlush : GLContext
  • GLFogCoordPointer : GLContext
  • GLFogf : GLContext
  • GLFogfv : GLContext
  • GLFogi : GLContext
  • GLFogiv : GLContext
  • GLFrontFace : GLContext
  • GLFrustum : GLContext
  • GLGenBuffers : GLContext
  • GLGenLists : GLContext
  • GLGenOcclusionQueries : GLContext
  • GLGenPrograms : GLContext
  • GLGenQueries : GLContext
  • GLGenTextures : GLContext
  • GLGetBooleanv : GLContext
  • GLGetClipPlane : GLContext
  • GLGetDoublev : GLContext
  • GLGetFloatv : GLContext
  • GLGetIntegerv : GLContext
  • GLGetLightfv : GLContext
  • GLGetLightiv : GLContext
  • GLGetMapdv : GLContext
  • GLGetMapfv : GLContext
  • GLGetMapiv : GLContext
  • GLGetMaterialfv : GLContext
  • GLGetMaterialiv : GLContext
  • GLGetMaxTexCoords : GLContext
  • GLGetMaxTexImageUnits : GLContext
  • GLGetMaxTexUnits : GLContext
  • GLGetOcclusionQueryuiv : GLContext
  • GLGetPixelMapfv : GLContext
  • GLGetPixelMapuiv : GLContext
  • GLGetPixelMapusv : GLContext
  • GLGetPointerv : GLContext
  • GLGetPolygonStipple : GLContext
  • GLGetQueryiv : GLContext
  • GLGetQueryObjectiv : GLContext
  • GLGetQueryObjectuiv : GLContext
  • GLGetString : GLContext
  • GLGetTexEnvfv : GLContext
  • GLGetTexEnviv : GLContext
  • GLGetTexGendv : GLContext
  • GLGetTexGenfv : GLContext
  • GLGetTexGeniv : GLContext
  • GLGetTexImage : GLContext
  • GLGetTexLevelParameterfv : GLContext
  • GLGetTexLevelParameteriv : GLContext
  • GLGetTexParameterfv : GLContext
  • GLGetTexParameteriv : GLContext
  • GLHint : GLContext
  • GLIndexd : GLContext
  • GLIndexf : GLContext
  • GLIndexi : GLContext
  • GLIndexMask : GLContext
  • GLIndexPointer : GLContext
  • GLIndexs : GLContext
  • GLIndexub : GLContext
  • GLInitNames : GLContext
  • GLInterleavedArrays : GLContext
  • GLIsBuffer : GLContext
  • GLIsEnabled : GLContext
  • GLIsExtensionAvailable : GLContext
  • GLIsExtensionExported : GLContext
  • GLIsList : GLContext
  • GLIsOcclusionQuery : GLContext
  • GLIsProgram : GLContext
  • GLIsQuery : 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
  • GLLightQuadraticAttenuation : GLContext
  • GLLightSpecular : GLContext
  • GLLightSpotCutoff : GLContext
  • GLLightSpotDirection : GLContext
  • GLLightSpotExponent : GLContext
  • GLLineStipple : GLContext
  • GLLineWidth : GLContext
  • GLListBase : GLContext
  • GLLoadIdentity : GLContext
  • GLLoadMatrixd : GLContext
  • GLLoadMatrixf : GLContext
  • GLLoadName : GLContext
  • GLLoadProgram : GLContext
  • GLLoadTransposedMatrixd : GLContext
  • GLLoadTransposeMatrixf : 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
  • GLMultiDrawElements : GLContext
  • GLMultiTexCoord2f : GLContext
  • GLMultMatrixd : GLContext
  • GLMultMatrixf : GLContext
  • GLMultTransposeMatrixd : GLContext
  • GLMultTransposeMatrixf : GLContext
  • GLNewList : GLContext
  • GLNormal3b : GLContext
  • GLNormal3bv : GLContext
  • GLNormal3d : GLContext
  • GLNormal3dv : GLContext
  • GLNormal3f : GLContext
  • GLNormal3fv : GLContext
  • GLNormal3i : GLContext
  • GLNormal3iv : GLContext
  • GLNormal3s : GLContext
  • GLNormal3sv : GLContext
  • GLNormalPointer : GLContext
  • GLOrtho : GLContext
  • GLPassThrough : GLContext
  • GLPixelMapfv : GLContext
  • GLPixelMapuiv : GLContext
  • GLPixelMapusv : GLContext
  • GLPixelStoref : GLContext
  • GLPixelStorei : GLContext
  • GLPixelTransferf : GLContext
  • GLPixelTransferi : GLContext
  • GLPixelZoom : GLContext
  • GLPointSize : GLContext
  • GLPolygonMode : GLContext
  • GLPolygonModeBack : GLContext
  • GLPolygonModeFront : GLContext
  • GLPolygonModeFrontAndBack : GLContext
  • GLPolygonOffset : GLContext
  • GLPolygonStipple : GLContext
  • GLPopAttrib : GLContext
  • GLPopClientAttrib : GLContext
  • GLPopMatrix : GLContext
  • GLPopName : GLContext
  • GLPrimitiveRestartIndex : GLContext
  • GLPrioritizeTextures : GLContext
  • GLProgramNamedParameter4f : 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
  • GLRenderMode : GLContext
  • GLRotated : GLContext
  • GLRotatef : GLContext
  • GLScaled : GLContext
  • GLScalef : GLContext
  • GLScissor : GLContext
  • GLSecondaryColorPointer : GLContext
  • GLSelectBuffer : GLContext
  • GLSetWindowStereoMode : GLContext
  • GLShadeModel : GLContext
  • GLStencilFunc : GLContext
  • GLStencilMask : GLContext
  • GLStencilOp : GLContext
  • GLTexCoord1d : GLContext
  • GLTexCoord1f : GLContext
  • GLTexCoord1i : GLContext
  • GLTexCoord1s : GLContext
  • GLTexCoord2d : GLContext
  • GLTexCoord2f : GLContext
  • GLTexCoord2fv : GLContext
  • GLTexCoord2i : GLContext
  • GLTexCoord2s : GLContext
  • GLTexCoord3d : GLContext
  • GLTexCoord3f : GLContext
  • GLTexCoord3i : GLContext
  • GLTexCoord3s : GLContext
  • GLTexCoord4d : GLContext
  • GLTexCoord4f : GLContext
  • GLTexCoord4i : GLContext
  • GLTexCoord4s : 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
  • GLTexParameteriv : GLContext
  • GLTexSubImage1D : GLContext
  • GLTexSubImage2D : GLContext
  • GLTextureBorderColor : GLContext
  • GLTextureEnvColor : GLContext
  • GLTextureEnvMode : GLContext
  • GLTextureMagFilter : GLContext
  • GLTextureMinFilter : GLContext
  • GLTextureWrapR : GLContext
  • GLTextureWrapS : GLContext
  • GLTextureWrapT : GLContext
  • GLTranslated : GLContext
  • GLTranslatef : GLContext
  • GLUnmapBuffer : GLContext
  • GLVertex2d : GLContext
  • GLVertex2f : GLContext
  • GLVertex2i : GLContext
  • GLVertex2s : GLContext
  • GLVertex3d : GLContext
  • GLVertex3f : GLContext
  • GLVertex3fv : GLContext
  • GLVertex3i : GLContext
  • GLVertex3s : GLContext
  • GLVertex4d : GLContext
  • GLVertex4f : GLContext
  • GLVertex4i : GLContext
  • GLVertex4s : GLContext
  • GLVertexPointer : GLContext
  • GLViewport : GLContext
  • GLXCreateContext : GLContext
  • GLXDestroyContext : GLContext
  • GLXGetCurrentContext : GLContext
  • GLXGetCurrentDrawable : GLContext

- i -

  • intersectingSphere() : Sphere3f
  • invalidate() : Sphere3f, HighlightObject
  • isEmpty() : Sphere3f, Path
  • isIdentity() : Matnnf
  • isNormalized() : Vecnf, Quatf, Matnnf
  • isNull() : Vecnf, Quatf, Matnnf
  • isOrthogonal() : Matnnf
  • isRotation() : Mat33f

- l -

  • length() : Vecnf
  • lengthd() : Vecnf
  • lengthSquared() : Vecnf
  • lerp() : Trafo, Quatf

- m -

  • magnitude() : Quatf
  • maxElement() : Vecnf
  • minElement() : Vecnf

- n -

  • nearestPoint() : Plane3f
  • normalize() : Vec3f, Vecnf, Quatf

- o -

  • operator *() : Vecnf, Vec4f, Vec3f, Vec2f, Matnnf, Mat44f, PointerReference, RCObject_AutoPtr, RCIPtr, RCPtr, Lockable, Vecnf, Quatf, Matnnf, Offset_AutoPtr
  • operator!= : CullData, PointerReference, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VariantIterator, Vecnf, Sphere3f, Quatf, Plane3f, Matnnf
  • operator< : UPIID, UPITID
  • operator== : CullData, PointerReference, UPIID, UPITID, Incarnation, Chunk, MouseInput, KeyInput, VNVector, VariantIterator, Bone, Vecnf, Trafo, Sphere3f, Quatf, Plane3f, Matnnf
  • operator^() : Vec3f

- q -

  • queryInterfaceType : PlugInServer

- r -

  • releaseInterface : PlugInServer

- s -

  • setIdentity() : Matnnf, Trafo
  • setPlugInFileFilter : PlugInServer
  • signedDistance() : Plane3f
  • smoothNormals() : Vec3f

- w -

  • WGLBindSwapBarrierNV : GLContext
  • WGLBindTexImage : GLContext
  • WGLChoosePixelFormat : GLContext
  • WGLCreateContext : GLContext
  • WGLCreatePbuffer : GLContext
  • WGLDeleteContext : GLContext
  • WGLDestroyPbuffer : 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 Fri Aug 4 08:36:30 2006 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions

  • iterator : SearchTraverser
  • theAllocator : IAllocator
Generated on Fri Aug 4 08:36:30 2006 for NVSGSDK by NVIDIA


Compound Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values | Related Functions
a | b | c | d | e | f | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | y

- a -

  • active : plane_t
  • activeChildren : NBFSwitch
  • activeKey : NBFStateSet
  • ambient : NVSGMaterial, NVSGLight
  • ambientColor : NBFLightSource, NBFScene
  • animation : NBFLightSource, NBFAnimatedTransform, NBFAnimatedIndependents, bone_t
  • antiAliasing : NBFPointAttribute, NBFLineAttribute
  • AREAOFPEACE : WalkCameraManipulator, FlightCameraManipulator
  • attenuation : NBFSpotLight, NBFPointLight

- b -

  • backAmbientColor : NBFMaterial
  • backColor : NBFScene
  • backDiffuseColor : NBFMaterial
  • backEmissiveColor : NBFMaterial
  • backFaceMode : NBFFaceAttribute
  • backOpacity : NBFMaterial
  • backSpecularColor : NBFMaterial
  • backSpecularExponent : NBFMaterial
  • bindings : NBFTextureAttribute
  • bones : skin_t
  • bpi : texImage_t
  • bpp : texImage_t
  • bps : texImage_t
  • byteOrder : NBFHeader

- c -

  • camera : NBFViewState
  • cameraAnimations : NBFScene
  • cameras : NBFScene
  • castShadow : NBFLightSource
  • center : NBFLOD, trafo_t
  • chars : str_t
  • children : NBFGroup
  • clipPlanes : NBFGroup
  • colorDim : NBFVertexAttributeSet
  • colors : NBFVertexAttributeSet
  • constantAttenuation : NVSGLight
  • context : PlugInCallback::InvalidFileInfo, PlugInCallback::IncompatibleFileInfo, PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo
  • coordDim : texCoordSet_t
  • 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
  • DOLLY1 : TrackballTransformManipulator, TrackballCameraManipulator
  • DOLLY2 : TrackballTransformManipulator, TrackballCameraManipulator
  • drawables : geometrySet_t

- e -

  • emission : NVSGMaterial
  • emptyCount : EmptyResult
  • 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
  • flags : texImage_t
  • FLYBACKWARD : FlightCameraManipulator
  • FLYFORWARD : FlightCameraManipulator
  • focusDist : NBFCamera
  • fogCoords : NBFVertexAttributeSet
  • frontAmbientColor : NBFMaterial
  • frontDiffuseColor : NBFMaterial
  • frontEmissiveColor : NBFMaterial
  • frontFaceMode : NBFFaceAttribute
  • frontOpacity : NBFMaterial
  • frontSpecularColor : NBFMaterial
  • frontSpecularExponent : NBFMaterial

- h -

  • headLights : NBFCamera
  • height : texImage_t, meshSet_t
  • hourLastModified : NBFHeader

- i -

  • identityCount : IdentityResult
  • INCREASESPEED : WalkCameraManipulator, FlightCameraManipulator
  • indices : NBFIndependentPrimitiveSet, meshSet_t, indexSet_t
  • intensity : NBFLightSource
  • isAutoClipPlanes : Camera, NBFCamera
  • isJitter : ViewState, NBFViewState
  • isShared : PointerReference, RCObject, NBFObject
  • isStereo : ViewState, NBFViewState
  • isStereoAutomatic : NBFViewState

- j -

  • jitters : NBFViewState

- k -

  • key : keyVariant_t
  • keys : NBFInterpolatedAnimation
  • keyStateVariantPairs : NBFStateSet

- l -

  • linearAttenuation : NVSGLight

- m -

  • m_animationFrame : AppTraverser
  • m_appTraverser : RenderArea
  • m_bApplyingCgFx : AppTraverser
  • m_bones : Skin
  • m_buttonState : MouseInput
  • m_cameraAnimation : AnimationManipulator
  • m_cullStack : Traverser
  • m_cullTraverser : RenderArea
  • m_currentFrame : AnimationManipulator
  • m_currentX : MouseInput
  • m_currentY : MouseInput
  • m_dist : Intersection
  • m_features : RenderArea
  • m_hdc : GLWinRenderArea
  • m_hglrc : GLWinRenderArea
  • m_hSensitivity : WalkCameraManipulator, FlightCameraManipulator
  • m_idRenderArea : RenderArea
  • m_indices : Face
  • m_interrupt : Traverser
  • m_interrupted : Traverser
  • m_isCritical : ProblemInfo
  • m_isp : Intersection
  • m_keyInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_keyState : KeyInput
  • m_lastX : MouseInput
  • m_lastY : MouseInput
  • m_lodStack : Traverser
  • m_missingFeatures : ProblemInfo
  • m_mouseInput : WalkCameraManipulator, TrackballTransformManipulator, TrackballCameraManipulator, FlightCameraManipulator
  • m_normal : Skin
  • m_nullStateSet : Traverser
  • m_numberOfFrames : AnimationManipulator
  • m_numMSBuffers : RenderArea
  • m_objectCode : Object
  • m_pDrawable : Intersection
  • m_pPath : Intersection
  • m_primitiveIndex : Intersection
  • m_problem : ProblemInfo
  • m_problemLog : RenderArea, Traverser
  • m_raCreated : RenderArea
  • m_raHeight : RenderArea
  • m_raWidth : RenderArea
  • m_renderArea : Manipulator
  • m_renderTraverser : RenderArea
  • m_scene : RenderArea
  • m_ScreenSizeX : WalkCameraManipulator, FlightCameraManipulator
  • m_ScreenSizeY : WalkCameraManipulator, FlightCameraManipulator
  • m_speed : WalkCameraManipulator, FlightCameraManipulator
  • m_speedIncreaseFactor : WalkCameraManipulator, FlightCameraManipulator
  • m_startX : MouseInput
  • m_startY : MouseInput
  • m_tbsize : Trackball
  • m_trafo : LightSource
  • m_transformPath : TransformManipulator
  • m_transformStack : ModelViewTraverser
  • m_traverser : NBFSaver
  • m_vertex : Skin
  • m_vertexIndices : Intersection
  • m_viewState : RenderArea, Traverser
  • m_vSensitivity : FlightCameraManipulator
  • m_worldUpVector : WalkCameraManipulator, FlightCameraManipulator
  • magFilter : NBFTextureAttributeItem
  • meshes : NBFMeshedPrimitiveSet
  • minFilter : NBFTextureAttributeItem
  • minuteLastModified : NBFHeader
  • missingCount : MissingResult
  • monthLastModified : NBFHeader

- n -

  • name : sampler_t, tweak_t
  • nbfBugfixLevel : NBFHeader
  • nbfMajorVersion : NBFHeader
  • nbfMinorVersion : NBFHeader
  • nearDist : NBFCamera
  • normal : plane_t, skin_t
  • normals : VNVector, NBFVertexAttributeSet
  • normalSets : NBFVNVectorAnimation
  • nullNormalsCount : NullNormalsResult
  • nullNormalsNumber : NullNormalsResult
  • numActiveChildren : NBFSwitch
  • numberOfAnimationFrames : NBFScene
  • numBindings : NBFTextureAttribute
  • numBones : skin_t
  • numCameraAnimations : NBFScene
  • numCameras : NBFScene
  • numChars : str_t
  • numChildren : NBFGroup
  • numClipPlanes : NBFGroup
  • numColors : NBFVertexAttributeSet
  • numDrawables : geometrySet_t
  • numFogCoords : NBFVertexAttributeSet
  • numFrames : NBFFramedAnimation
  • numHeadLights : NBFCamera
  • numIndices : NBFIndependentPrimitiveSet, indexSet_t
  • numJitters : NBFViewState
  • numKeys : NBFInterpolatedAnimation
  • numMeshes : NBFMeshedPrimitiveSet
  • numNormals : NBFVertexAttributeSet, NBFVNVectorAnimation
  • numRanges : NBFLOD
  • numSamplers : NBFCgFx
  • numSecondaryColors : NBFVertexAttributeSet
  • numSkins : NBFSkinnedTriangles
  • numStateAttribs : NBFStatePass
  • numStatePasses : NBFStateVariant
  • numStateVariants : NBFStateSet
  • numStrips : NBFStrippedPrimitiveSet
  • numTexCoords : texCoordSet_t
  • numTexCoordsSets : NBFVertexAttributeSet
  • numTweaks : NBFCgFx
  • numVertices : NBFVertexAttributeSet, NBFVNVectorAnimation
  • nvsgBugfixLevel : NBFHeader
  • nvsgMajorVersion : NBFHeader
  • nvsgMinorVersion : NBFHeader

- o -

  • 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::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UnexpectedTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::InvalidValueInfo, PlugInCallback::IncompatibleValueInfo, PlugInCallback::EmptyTokenInfo, NBFSpotLight, NBFPointLight, NBFCamera

- q -

  • quadraticAttenuation : NVSGLight

- r -

  • ranges : NBFLOD
  • reducedCount : EquivalenceResult
  • reserved : NBFHeader
  • root : NBFScene
  • ROTATE : TrackballTransformManipulator

- s -

  • scaleOrientation : trafo_t
  • scaling : trafo_t
  • scene : NBFHeader
  • secondaryColorDim : NBFVertexAttributeSet
  • secondaryColors : NBFVertexAttributeSet
  • secondLastModified : NBFHeader
  • shininess : NVSGMaterial
  • shortStrippedCount : ShortStrippedResult
  • shortStrippedNumber : ShortStrippedResult
  • signature : NBFHeader
  • singleChildCount : SingleChildResult
  • size : NBFPointAttribute
  • skins : NBFSkinnedTriangles
  • source : NBFCgFx
  • sourceFunction : NBFBlendAttribute
  • sourceObject : NBFObject
  • specular : NVSGMaterial, NVSGLight
  • specularColor : NBFLightSource
  • spotCutoff : NVSGLight
  • spotExponent : NVSGLight
  • stateAttribs : NBFStatePass
  • statePasses : NBFStateVariant
  • stateSet : geometrySet_t
  • stereoAutomaticFactor : NBFViewState
  • stereoEyeDistance : NBFViewState
  • stippleFactor : NBFLineAttribute
  • stipplePattern : NBFLineAttribute
  • str : tweak_t
  • strips : NBFStrippedPrimitiveSet
  • systemHints : NBFNode
  • systemSpecificErrorCode : PlugInCallback::FileMappingFailedInfo, PlugInCallback::FileAccessFailedInfo

- t -

  • targetDistance : NBFViewState
  • texAttribItem : texBinding_t
  • texBorderColor : NBFTextureAttributeItem
  • texCoords : texCoordSet_t
  • texCoordsSets : NBFVertexAttributeSet
  • texEnvColor : NBFTextureAttributeItem
  • texEnvMode : NBFTextureAttributeItem
  • texGenMode : NBFTextureAttributeItem
  • texGenPlane : NBFTextureAttributeItem
  • texImg : NBFTextureAttributeItem, sampler_t
  • texUnit : texBinding_t
  • texWrapR : NBFTextureAttributeItem
  • texWrapS : NBFTextureAttributeItem
  • texWrapT : NBFTextureAttributeItem
  • TILT : WalkCameraManipulator
  • token : PlugInCallback::UnsupportedTokenInfo, PlugInCallback::UnknownTokenInfo, PlugInCallback::UndefinedTokenInfo, PlugInCallback::EmptyTokenInfo
  • trafo : NBFTextureAttributeItem
  • trafos : NBFTrafoAnimation
  • TRANSLATE : WalkCameraManipulator
  • translation : trafo_t
  • tweaks : tweak_t
  • twoSidedLighting : NBFFaceAttribute

- u -

  • upVector : NBFCamera
  • userHints : NBFNode

- 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
  • vertex : skin_t
  • vertexAttributeSet : NBFPrimitiveSet
  • vertexSets : NBFVNVectorAnimation
  • vertices : VNVector, NBFVertexAttributeSet
  • viewState : NBFHeader

- w -

  • WALKBACKWARD : WalkCameraManipulator
  • WALKFORWARD : WalkCameraManipulator
  • weight : bone_t
  • width : NBFLineAttribute, texImage_t, meshSet_t
  • windowOffset : NBFCamera
  • windowSize : NBFCamera

- y -

  • yearLastModified : NBFHeader
Generated on Fri Aug 4 08:36:30 2006 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 Fri Aug 4 08:37:11 2006 for NVSGSDK by NVIDIA


nvgl Namespace Reference

Namespace for OpenGL. More...

Classes

class | GLContext
Wrapper for OpenGL functions to provide caching, extension handling, and, in debug mode, error handling per context. More...

class | GLContext::GLLocks
struct | GLDALDataCreator
struct | GLDALData
struct | GLTextureCache
struct | GLDisplayListCache
struct | GLArrayBufferCache
struct | GLElementArrayBufferCache
class | GLFunctions
The GLFunctions class holds the OpenGL extension function pointers. More...

class | GLObjects
The GLObjects class is a container of OpenGL objects. More...

struct | GLObjects::GLShareables

Enumerations

enum {
GL_INVALID_BUFFER_TARGET = -1, GL_VERTEX_BUFFER_INTERLEAVED_GENERIC = 0, GL_VERTEX_BUFFER_FIRST = GL_VERTEX_BUFFER_INTERLEAVED_GENERIC, GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F,
GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F_T2F, GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F_T2F_TG3F_BN3F, GL_VERTEX_BUFFER_LAST = GL_VERTEX_BUFFER_INTERLEAVED_V3F_N3F_T2F_TG3F_BN3F, GL_INDEX_BUFFER_GENERIC,
GL_INDEX_BUFFER_FIRST = GL_INDEX_BUFFER_GENERIC, 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_VBO = 0x00000001, GL_DL = 0x00000002, GL_TEX = 0x00000004 }

Functions

GLContext * | glContext ()
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 | GLActiveTexture (GLenum texture)
Replacement of glActiveTexture.

void | GLAlphaFunc (GLenum func, GLclampf ref)
Replacement of glAlphaFunc.

GLboolean | GLAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences)
Replacement of glAreTexturesResident.

void | GLArrayElement (GLint i)
Replacement of glArrayElement.

void | GLBegin (GLenum mode)
Replacement of glBegin.

void | GLBeginOcclusionQuery (GLuint id)
Replacement of glBeginOcclusionQueryNV.

void | GLBeginQuery (GLenum target, GLuint id)
Replacement of glBeginQueryARB.

void | GLBindBuffer (GLenum target, GLuint id)
Replacement of glBindBufferARB.

void | GLBufferData (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage)
Replacement of glBufferDataARB.

void | GLBufferSubData (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data)
Replacement of glBufferSubDataARB.

void | GLDeleteBuffers (GLsizei n, const GLuint *buffers)
Replacement of glDeleteBuffersARB.

void | GLGenBuffers (GLsizei n, GLuint *buffers)
Replacement of glGenBuffersARB.

GLvoid * | GLMapBuffer (GLenum target, GLenum access)
Replacement of glMapBufferARB.

GLboolean | GLUnmapBuffer (GLenum target)
Replacement of glUnmapBufferARB.

GLboolean | GLIsBuffer (GLuint name)
Replacement of glIsBufferARB.

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 | GLBlendFunc (GLenum sfactor, GLenum dfactor)
Replacement of glBlendFunc.

void | GLBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
Replacement of glBlendFunc.

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 | 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 | GLClearDepth (GLclampd depth)
Replacement of glClearDepth.

void | GLClearIndex (GLfloat c)
Replacement of glClearIndex.

void | GLClearStencil (GLint s)
Replacement of glClearStencil.

void | GLClientActiveTexture (GLenum texture)
Replacement of glClientActiveTexture.

void | GLClipPlane (GLenum plane, const GLdouble *equation)
Replacement of glClipPlane.

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 | 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 | 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 | GLColorMaterial (GLenum face, GLenum mode)
Replacement of glColorMaterial.

void | GLColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glColorPointer.

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 | 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 | GLCullFace (GLenum mode)
Replacement of glCullFace.

void | GLCullFaceLock (GLenum mode)
void | GLCullFaceUnlock (GLenum mode)
void | GLDeleteLists (GLuint list, GLsizei range)
Replacement of glDeleteLists.

void | GLDeleteOcclusionQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteOcclusionQueriesNV.

void | GLDeletePrograms (GLsizei n, const GLuint *ids)
Replacement of glDeleteProgramsNV.

void | GLDeleteQueries (GLsizei n, const GLuint *ids)
Replacement of glDeleteQueriesARB.

void | GLDeleteTextures (GLsizei n, const GLuint *textures)
Replacement of glDeleteTextures.

void | GLDepthFunc (GLenum func)
Replacement of glDepthFunc.

void | GLDepthMask (GLboolean flag)
Replacement of glDepthMask.

void | GLDepthRange (GLclampd znear, GLclampd zfar)
Replacement of glDepthRange.

void | GLDisableBlend (void)
Cached version of GLDisable( GL_BLEND ).

void | GLDisableColorMaterial (void)
Cached version of GLDisable( GL_COLOR_MATERIAL ).

void | GLDisableCullFace (void)
Cached version of GLDisable( GL_CULL_FACE ).

void | GLDisableCullFaceLock (void)
void | GLDisableCullFaceUnlock (void)
void | GLDisableDepthTest (void)
Cached version of GLDisable( GL_DEPTH_TEST ).

void | GLDisableLighting (void)
Cached version of GLDisable( GL_LIGHTING ).

void | GLDisableLightingLock (void)
void | GLDisableLightingUnlock (void)
void | GLDisableLineSmooth (void)
Cached version of GLDisable( GL_LINE_SMOOTH ).

void | GLDisableLineStipple (void)
Cached version of GLDisable( GL_LINE_STIPPLE ).

void | GLDisableNormalize (void)
Cached version of GLDisable( GL_NORMALIZE ).

void | GLDisablePointSmooth (void)
Cached version of GLEnable( 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 | GLDisablePolygonStipple (void)
Cached version of GLDisable( GL_POLYGON_STIPPLE ).

void | GLDisableTexture (GLenum target)
Cached version of GLDisable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 | GLDrawArrays (GLenum mode, GLint first, GLsizei count)
Replacement of glDrawArrays.

void | GLDrawBuffer (GLenum mode)
Replacement of glDrawBuffer.

void | GLDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
Replacement of glDrawElements.

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 | GLEnableBlend (void)
Cached version of GLEnable( GL_BLEND ).

void | GLEnableColorMaterial (void)
Cached version of GLEnable( GL_COLOR_MATERIAL ).

void | GLEnableCullFace (void)
Cached version of GLEnable( GL_CULL_FACE ).

void | GLEnableCullFaceLock (void)
void | GLEnableCullFaceUnlock (void)
void | GLEnableDepthTest (void)
Cached version of GLEnable( GL_DEPTH_TEST ).

void | GLEnableLighting (void)
Cached version of GLEnable( GL_LIGHTING ).

void | GLEnableLineSmooth (void)
Cached version of GLEnable( GL_LINE_SMOOTH ).

void | GLEnableLineStipple (void)
Cached version of GLEnable( GL_LINE_STIPPLE ).

void | GLEnableNormalize (void)
Cached version of GLEnable( GL_NORMALIZE ).

void | GLEnablePointSmooth (void)
Cached version of GLEnable( GL_POINT_SMOOTH ).

void | GLEnablePolygonOffsetFill (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_FILL ).

void | GLEnablePolygonOffsetLine (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_LINE ).

void | GLEnablePolygonOffsetPoint (void)
Cached version of GLEnable( GL_POLYGON_OFFSET_POINT ).

void | GLEnablePolygonStipple (void)
Cached version of GLEnable( GL_POLYGON_STIPPLE ).

void | GLEnableTexture (GLenum target)
Cached version of GLEnable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 | GLEnd (void)
Replacement of glEnd.

void | GLEndList (void)
Replacement of glEndList.

void | GLEndOcclusionQuery (void)
Replacement of glEndOcclusionQueryNV.

void | GLEndQuery (GLenum target)
Replacement of glEndQueryARB.

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 | GLFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)
Replacement of glFeedbackBuffer.

void | GLFinish (void)
Replacement of glFinish.

void | GLFlush (void)
Replacement of glFlush.

void | GLFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glFogCoordPointer.

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 | GLFrontFace (GLenum mode)
Replacement of glFrontFace.

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 glGenQueriesARB.

void | GLGenTextures (GLsizei n, GLuint *textures)
Replacement of glGenTextures.

void | GLGetBooleanv (GLenum pname, GLboolean *params)
Replacement of glGetBooleanv.

void | GLGetDoublev (GLenum pname, GLdouble *params)
Replacement of glGetDoublev.

void | GLGetFloatv (GLenum pname, GLfloat *params)
Replacement of glGetFloatv.

void | GLGetIntegerv (GLenum pname, GLint *params)
Replacement of glGetIntegerv.

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 | 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 | GLGetQueryiv (GLenum target, GLenum pname, GLint *params)
Replacement of glGetQueryivARB.

void | GLGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
Replacement of glGetQueryObjectivARB.

void | GLGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
Replacement of glGetQueryObjectuivARB.

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 | GLHint (GLenum target, GLenum mode)
Replacement of glHint.

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 | 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 | GLIsList (GLuint list)
Replacement of glIsList.

GLboolean | GLIsOcclusionQuery (GLuint id)
Replacement of glIsOcclusionQueryNV.

GLboolean | GLIsProgram (GLuint id)
Replacement of glIsProgramNV.

GLboolean | GLIsQuery (GLuint id)
Replacement of glIsQueryARB.

GLboolean | GLIsTexture (GLuint texture)
Replacement of glIsTexture.

void | GLLightAmbient (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_AMBIENT, param ).

void | GLLightConstantAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_CONSTANT_ATTENUATION, param ).

void | GLLightDiffuse (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_DIFFUSE, param ).

void | GLLightLinearAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_LINEAR_ATTENUATION, param ).

void | GLLightPosition (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_POSITION, param ).

void | GLLightQuadraticAttenuation (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_QUADRATIC_ATTENUATION, param ).

void | GLLightSpecular (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_SPECULAR, param ).

void | GLLightSpotCutoff (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_SPOT_CUTOFF, param ).

void | GLLightSpotDirection (GLenum light, const GLfloat *params)
Cached version of GLLightfv( light, GL_SPOT_DIRECTION, param ).

void | GLLightSpotExponent (GLenum light, GLfloat param)
Cached version of GLLightf( light, GL_SPOT_EXPONENT, param ).

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 GLLightModelAmbient.

void | GLLightModelLocalViewer (GLint param)
Replacement of GLLightModelLocalViewer.

void | GLLightModelTwoSide (GLint param)
Replacement of GLLightModelTwoSide.

void | GLLightModelTwoSideLock (GLint param)
void | GLLightModelTwoSideUnlock (GLint param)
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 | GLLineWidth (GLfloat width)
Replacement of glLineWidth.

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 | 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 | GLMaterialShininessFront (GLfloat param)
Cached version of GLMaterialf( GL_FRONT, GL_SHININESS, param ).

void | GLMaterialShininessFrontAndBack (GLfloat param)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, param ).

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 | GLMaterialAmbientFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_AMBIENT, param ).

void | GLMaterialAmbientFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_AMBIENT, param ).

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 | GLMaterialDiffuseFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_DIFFUSE, param ).

void | GLMaterialDiffuseFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_DIFFUSE, param ).

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 | GLMaterialEmissionFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_EMISSION, param ).

void | GLMaterialEmissionFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_EMISSION, param ).

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 | GLMaterialSpecularFront (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT, GL_SPECULAR, param ).

void | GLMaterialSpecularFrontAndBack (const GLfloat *params)
Cached version of GLMaterialf( GL_FRONT_AND_BACK, GL_SPECULAR, param ).

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 | GLMultiTexCoord2f (GLenum texture, GLfloat tx, GLfloat ty)
Replacement of glMultiTexCoord2f.

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 | 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 | 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 | GLPointSize (GLfloat size)
Replacement of glPointSize.

void | GLPolygonModeBack (GLenum mode)
Cached version of GLPolygonMode( GL_BACK, mode ).

void | GLPolygonModeFront (GLenum mode)
Cached version of GLPolygonMode( GL_FRONT, mode ).

void | GLPolygonModeFrontAndBack (GLenum mode)
Cached version of GLPolygonMode( GL_FRONT_AND_BACK, mode ).

void | GLPolygonMode (GLenum face, GLenum mode)
Cached version of GLPolygonMode( face, mode ).

void | GLPolygonModeLock (GLenum face, GLenum mode)
void | GLPolygonModeUnlock (GLenum face, GLenum mode)
void | GLPolygonOffset (GLfloat factor, GLfloat units)
Replacement of glPolygonOffset.

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 | GLPrimitiveRestartIndex (GLuint index)
Replacement of glPrimitiveRestartIndex.

void | GLPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)
Replacement of glPrioritizeTextures.

void | GLProgramNamedParameter4f (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glProgramNamedParameter4fNV.

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 | 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 | GLScissor (GLint x, GLint y, GLsizei width, GLsizei height)
Replacement of glScissor.

void | GLSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
Replacement of glSecondaryColorPointer.

void | GLSelectBuffer (GLsizei size, GLuint *buffer)
Replacement of glSelectBuffer.

void | GLSetWindowStereoMode (GLboolean displayMode)
Replacement of glSetWindowStereoModeNV.

void | GLShadeModel (GLenum mode)
Replacement of glShadeModel.

void | GLStencilFunc (GLenum func, GLint ref, GLuint mask)
Replacement of glStencilFunc.

void | GLStencilMask (GLuint mask)
Replacement of glStencilMask.

void | GLStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
Replacement of glStencilOp.

void | GLTexCoord1d (GLdouble s)
Replacement of glTexCoord1d.

void | GLTexCoord1f (GLfloat s)
Replacement of glTexCoord1f.

void | GLTexCoord1i (GLint s)
Replacement of glTexCoord1i.

void | GLTexCoord1s (GLshort s)
Replacement of glTexCoord1s.

void | GLTexCoord2d (GLdouble s, GLdouble t)
Replacement of glTexCoord2d.

void | GLTexCoord2f (GLfloat s, GLfloat t)
Replacement of glTexCoord2f.

void | GLTexCoord2fv (const GLfloat *v)
Replacement of glTexCoord2fv.

void | GLTexCoord2i (GLint s, GLint t)
Replacement of glTexCoord2i.

void | GLTexCoord2s (GLshort s, GLshort t)
Replacement of glTexCoord2s.

void | GLTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
Replacement of glTexCoord3d.

void | GLTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
Replacement of glTexCoord3f.

void | GLTexCoord3i (GLint s, GLint t, GLint r)
Replacement of glTexCoord3i.

void | GLTexCoord3s (GLshort s, GLshort t, GLshort r)
Replacement of glTexCoord3s.

void | GLTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
Replacement of glTexCoord4d.

void | GLTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
Replacement of glTexCoord4f.

void | GLTexCoord4i (GLint s, GLint t, GLint r, GLint q)
Replacement of glTexCoord4i.

void | GLTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
Replacement of glTexCoord4s.

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 | 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 | 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 glTexSubImate1D.

void | GLTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
Replacement of glTexSubImate2D.

void | GLTranslated (GLdouble x, GLdouble y, GLdouble z)
Replacement of glTranslated.

void | GLTranslatef (GLfloat x, GLfloat y, GLfloat z)
Replacement of glTranslatef.

void | GLVertex2d (GLdouble x, GLdouble y)
Replacement of glVertex2d.

void | GLVertex2f (GLfloat x, GLfloat y)
Replacement of glVertex2f.

void | GLVertex2i (GLint x, GLint y)
Replacement of glVertex2i.

void | GLVertex2s (GLshort x, GLshort y)
Replacement of glVertex2s.

void | GLVertex3d (GLdouble x, GLdouble y, GLdouble z)
Replacement of glVertex3d.

void | GLVertex3f (GLfloat x, GLfloat y, GLfloat z)
Replacement of glVertex3f.

void | GLVertex3fv (const GLfloat *v)
Replacement of glVertex3fv.

void | GLVertex3i (GLint x, GLint y, GLint z)
Replacement of glVertex3i.

void | GLVertex3s (GLshort x, GLshort y, GLshort z)
Replacement of glVertex3s.

void | GLVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
Replacement of glVertex4d.

void | GLVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
Replacement of glVertex4f.

void | GLVertex4i (GLint x, GLint y, GLint z, GLint w)
Replacement of glVertex4i.

void | GLVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)
Replacement of glVertex4s.

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.

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.

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 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 | 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 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.

NVSG_API GLsizeiptr | GLGetBaseBufferOffset ()
Returns the base buffer offset.

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

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 GLActiveTexture ( GLenum texture ) [inline]

Replacement of glActiveTexture.

This function stores the texture to activate for subsequent texture operations.

void GLAlphaFunc | ( | GLenum | func,
 |  | GLclampf | ref
 | ) | [inline]

Replacement of glAlphaFunc.

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 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 hides the extension character of glBeginOcclusionQueryNV and asserts on the result before returning.

void GLBeginQuery | ( | GLenum | target,
 |  | GLuint | id
 | ) | [inline]

Replacement of glBeginQueryARB.

This function hides the extension character of glBeginQueryARB and asserts on the result before returning.

void GLBindBuffer | ( | GLenum | target,
 |  | GLuint | id
 | ) | [inline]

Replacement of glBindBufferARB.

This function hides the extension character of glBindBufferARB, caches, and asserts on the result before returning.

void GLBufferData | ( | GLenum | target,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data,
 |  | GLenum | usage
 | ) | [inline]

Replacement of glBufferDataARB.

This function hides the extension character of glBufferDataARB and asserts on the result before returning.

void GLBufferSubData | ( | GLenum | target,
 |  | GLintptrARB | offset,
 |  | GLsizeiptrARB | size,
 |  | const GLvoid * | data
 | ) | [inline]

Replacement of glBufferSubDataARB.

This function hides the extension character of glBufferSubDataARB and asserts on the result before returning.

void GLDeleteBuffers | ( | GLsizei | n,
 |  | const GLuint * | buffers
 | ) | [inline]

Replacement of glDeleteBuffersARB.

This function hides the extension character of glDeleteBuffersARB, updates some caches, and asserts on the result before returning.

void GLGenBuffers | ( | GLsizei | n,
 |  | GLuint * | buffers
 | ) | [inline]

Replacement of glGenBuffersARB.

This function hides the extension character of glGenBuffersARB, asserts on the result, and updates some caches.

GLvoid* GLMapBuffer | ( | GLenum | target,
 |  | GLenum | access
 | ) | [inline]

Replacement of glMapBufferARB.

This function hides the extension character of glMapBufferARB and asserts on the result before returning.

GLboolean GLUnmapBuffer ( GLenum target ) [inline]

Replacement of glUnmapBufferARB.

This function hides the extension character of glUnmapBufferARB and asserts on the result before returning.

GLboolean GLIsBuffer ( GLuint name ) [inline]

Replacement of glIsBufferARB.

This function tests if for the current render context, name denotes a valid vertex buffer object.

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 GLBlendFunc | ( | GLenum | sfactor,
 |  | GLenum | dfactor
 | ) | [inline]

Replacement of glBlendFunc.

This function caches the blend func settings and asserts on the result before returning.

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 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 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 GLClearDepth ( GLclampd depth ) [inline]

Replacement of glClearDepth.

This function clears the depth setting and asserts on the result before returning.

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 asserts on the result before returning.

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 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 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 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 GLColorMaterial | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [inline]

Replacement of glColorMaterial.

This function asserts on the result before returning.

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 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 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 GLCullFace ( GLenum mode ) [inline]

Replacement of glCullFace.

This function caches the cull face setting and asserts on the result before returning.

void GLDeleteLists | ( | GLuint | list,
 |  | GLsizei | range
 | ) | [inline]

Replacement of glDeleteLists.

This function updates some caches and asserts on the result before returning.

void GLDeleteOcclusionQueries | ( | GLsizei | n,
 |  | const GLuint * | ids
 | ) | [inline]

Replacement of glDeleteOcclusionQueriesNV.

This function hides the extension character of glDeleteOcclusionQueriesNV, 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 glDeleteQueriesARB.

This function hides the extension character of glDeleteQueriesARB, updates some caches, and 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 GLDepthFunc ( GLenum func ) [inline]

Replacement of glDepthFunc.

This function asserts on the result before returning.

void GLDepthMask ( GLboolean flag ) [inline]

Replacement of glDepthMask.

This function asserts on the result before returning.

void GLDepthRange | ( | GLclampd | znear,
 |  | GLclampd | zfar
 | ) | [inline]

Replacement of glDepthRange.

This function asserts on the result before returning.

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 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 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 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 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 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 GLEnable( 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 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 GLDisableTexture ( GLenum target ) [inline]

Cached version of GLDisable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 GLDrawArrays | ( | GLenum | mode,
 |  | GLint | first,
 |  | GLsizei | count
 | ) | [inline]

Replacement of glDrawArrays.

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 GLDrawElements | ( | GLenum | mode,
 |  | GLsizei | count,
 |  | GLenum | type,
 |  | const GLvoid * | indices
 | ) | [inline]

Replacement of glDrawElements.

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 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 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 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 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 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 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 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 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 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 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 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 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 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 GLEnableTexture ( GLenum target ) [inline]

Cached version of GLEnable( [GL_TEXTURE_1D|GL_TEXTURE_2D|GL_TEXTURE_3D|GL_TEXTURE_CUBE_MAP|GL_TEXTURE_RECTANGLE_NV] ).

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 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 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 hides the extension character of glEndOcclusionQueryNV and asserts on the result before returning.

void GLEndQuery ( GLenum target ) [inline]

Replacement of glEndQueryARB.

This function hides the extension character of glEndQueryARB and 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 GLFeedbackBuffer | ( | GLsizei | size,
 |  | GLenum | type,
 |  | GLfloat * | buffer
 | ) | [inline]

Replacement of glFeedbackBuffer.

This function asserts on the result before returning.

void GLFinish ( void ) [inline]

Replacement of glFinish.

This function asserts on the result before returning.

void GLFlush ( void ) [inline]

Replacement of glFlush.

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 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 GLFrontFace ( GLenum mode ) [inline]

Replacement of glFrontFace.

This function caches the front face setting and asserts on the result before returning.

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 hides the extension character of glGenOcclusionQueriesNV and 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 glGenQueriesARB.

This function hides the extension character of glGenQueriesARB and 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 GLGetBooleanv | ( | GLenum | pname,
 |  | GLboolean * | params
 | ) | [inline]

Replacement of glGetBooleanv.

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 GLGetFloatv | ( | GLenum | pname,
 |  | GLfloat * | params
 | ) | [inline]

Replacement of glGetFloatv.

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 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 GLGetOcclusionQueryuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetOcclusionQueryuivNV.

This function hides the extension character of glGetOcclusionQueryuivNV and 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 GLGetQueryiv | ( | GLenum | target,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetQueryivARB.

This function hides the extension character of glGetQueryivARB and asserts on the result before returning.

void GLGetQueryObjectiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLint * | params
 | ) | [inline]

Replacement of glGetQueryObjectivARB.

This function hides the extension character of glGetQueryObjectivARB and asserts on the result before returning.

void GLGetQueryObjectuiv | ( | GLuint | id,
 |  | GLenum | pname,
 |  | GLuint * | params
 | ) | [inline]

Replacement of glGetQueryObjectuivARB.

This function hides the extension character of glGetQueryObjectuivARB and 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 GLHint | ( | GLenum | target,
 |  | GLenum | mode
 | ) | [inline]

Replacement of glHint.

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 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 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 id ) [inline]

Replacement of glIsProgramNV.

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 glIsQueryARB.

This function tests if for the current context, id denotes a valid query and 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 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 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 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 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 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 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 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 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 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 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 GLLightModelAmbient.

This function caches the light model settings and asserts on the result before returning.

void GLLightModelLocalViewer ( GLint param ) [inline]

Replacement of GLLightModelLocalViewer.

This function caches the light model settings and asserts on the result before returning.

void GLLightModelTwoSide ( GLint param ) [inline]

Replacement of GLLightModelTwoSide.

This function caches the light model settings and asserts on the result before returning.

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 GLLineWidth ( GLfloat width ) [inline]

Replacement of glLineWidth.

This function caches the line width setting and 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 GLMultiTexCoord2f | ( | GLenum | texture,
 |  | GLfloat | tx,
 |  | GLfloat | ty
 | ) | [inline]

Replacement of glMultiTexCoord2f.

This function hides the extension character of glMultiTexCoord2f and 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 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 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 GLPointSize ( GLfloat size ) [inline]

Replacement of glPointSize.

This function caches the point size setting and asserts on the result before returning.

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 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 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 GLPolygonMode | ( | GLenum | face,
 |  | GLenum | mode
 | ) | [inline]

Cached version of GLPolygonMode( face, mode ).

This function caches the polygon mode and assert on the result.

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 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 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 GLProgramNamedParameter4f | ( | GLuint | id,
 |  | GLsizei | len,
 |  | const GLubyte * | name,
 |  | GLfloat | x,
 |  | GLfloat | y,
 |  | GLfloat | z,
 |  | GLfloat | w
 | ) | [inline]

Replacement of glProgramNamedParameter4fNV.

This function hides the extension character of glProgramNamedParameter4fNV and 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 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 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 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 GLSetWindowStereoMode ( GLboolean displayMode ) [inline]

Replacement of glSetWindowStereoModeNV.

This function hides the extension character of glSetWindowStereoModeNV and 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 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 GLStencilMask ( GLuint mask ) [inline]

Replacement of glStencilMask.

This function caches the stencil mask setting and asserts on the result before returning.

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 GLTexCoord1d ( GLdouble s ) [inline]

Replacement of glTexCoord1d.

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 GLTexCoord1i ( GLint s ) [inline]

Replacement of glTexCoord1i.

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 GLTexCoord2d | ( | GLdouble | s,
 |  | GLdouble | t
 | ) | [inline]

Replacement of glTexCoord2d.

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 GLTexCoord2i | ( | GLint | s,
 |  | GLint | t
 | ) | [inline]

Replacement of glTexCoord2i.

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 GLTexCoord3d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r
 | ) | [inline]

Replacement of glTexCoord3d.

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 GLTexCoord3i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r
 | ) | [inline]

Replacement of glTexCoord3i.

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 GLTexCoord4d | ( | GLdouble | s,
 |  | GLdouble | t,
 |  | GLdouble | r,
 |  | GLdouble | q
 | ) | [inline]

Replacement of glTexCoord4d.

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 GLTexCoord4i | ( | GLint | s,
 |  | GLint | t,
 |  | GLint | r,
 |  | GLint | q
 | ) | [inline]

Replacement of glTexCoord4i.

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 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 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 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 glTexSubImate1D.

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 glTexSubImate2D.

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.

void GLVertex2d | ( | GLdouble | x,
 |  | GLdouble | y
 | ) | [inline]

Replacement of glVertex2d.

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 GLVertex2i | ( | GLint | x,
 |  | GLint | y
 | ) | [inline]

Replacement of glVertex2i.

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 GLVertex3d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z
 | ) | [inline]

Replacement of glVertex3d.

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 GLVertex3i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z
 | ) | [inline]

Replacement of glVertex3i.

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 GLVertex4d | ( | GLdouble | x,
 |  | GLdouble | y,
 |  | GLdouble | z,
 |  | GLdouble | w
 | ) | [inline]

Replacement of glVertex4d.

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 GLVertex4i | ( | GLint | x,
 |  | GLint | y,
 |  | GLint | z,
 |  | GLint | w
 | ) | [inline]

Replacement of glVertex4i.

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 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.

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.

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 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 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.

NVSG_API GLsizeiptr GLGetBaseBufferOffset ( )

Returns the base buffer offset.

The base buffer offset is NVSG module dependent. For a given NVSG module it is non-varying and equal for all vertex and index buffers.

Returns:
The base buffer offset used with the actual NVSG module.

Variable Documentation

NVSG_API GLenum glError

holds the current OpenGL error code to ease debugging

Generated on Fri Aug 4 08:37:14 2006 for NVSGSDK by NVIDIA


nvmath Namespace Reference

Namespace for mathematical helper functions and classes. More...

Classes

class | Mat33f
Two dimensional matrix of three times three floats. More...

class | Mat44f
Two dimensional matrix of four times four floats. More...

class | Matnnf
Template for two dimensional matrices of floats. More...

class | Plane3f
Plane class. More...

class | Quatf
Quaternion class. More...

class | Sphere3f
Sphere class. More...

class | Trafo
Transformation class. More...

class | Vec2f
Vector class with 2 float components. More...

class | Vec3f
Vector class with 3 float components. More...

class | Vec4f
Vector class with 4 float components. More...

class | Vecnf
Template class for one dimensional vectors of floats. More...

Functions

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.

float | degToRad (float angle)
Transform an angle in degrees to radians.

bool | isPowerOfTwo (int 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.

size_t | powerOfTwoBelow (size_t n)
Determine the largest integer power of two below an 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> float | square (const T &t)
Template to square an object of Type T.

template<unsigned char n> Vecnf< n > | orthonormalize (const Vecnf< n > &v0, const Vecnf< n > &v1)
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

NVSG_API const Sphere3f | cUnitSphere

Detailed Description

Namespace for mathematical helper functions and classes.

Function Documentation

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

float degToRad ( float angle ) [inline]

Transform an angle in degrees to radians.

Returns:
angle in radians
Parameters:
angle angle in degrees

bool isPowerOfTwo ( int n ) [inline]

Determine if an integer is a power of two.

Returns:
true if n is a power of two, otherwise false
Parameters:
n integer to test

T lerp | ( | float | alpha,
 |  | const T & | v0,
 |  | const T & | v1
 | ) |

Linear interpolation between two values v0 and v1.

v = v0 + alpha * ( v1 - v0 )

Parameters:
alpha | interpolation parameter
v0 | starting value
v1 | ending value

size_t powerOfTwoBelow ( size_t n ) [inline]

Determine the largest integer power of two below an integer.

Returns:
largest power of two below n
Parameters:
n integer to use as the upper limit

float radToDeg ( float angle ) [inline]

Transform an angle in radian to degree.

Returns:
angle in degrees
Parameters:
angle angle in radians

int sign ( const T & t )

Determine the sign of a scalar.

Returns:
sign of t
Parameters:
t scalar value

float square ( const T & t )

Template to square an object of Type T.

Returns:
product of t with itself
Parameters:
t object to square

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

NVSG_API const Sphere3f cUnitSphere

Global unit sphere.

Generated on Fri Aug 4 08:37:20 2006 for NVSGSDK by NVIDIA


nvsg Namespace Reference

Scenegrah classes - core NVSG. More...

Classes

class | AnimatedQuads
Class representing an animated Quads. More...

class | AnimatedTransform
Class representing an animated Transform. More...

class | AnimatedTriangles
Class representing an animated Triangles. More...

class | Animation
Class defining the common interface of an animation. More...

class | Billboard
Class that adds billboard properties to a Group. More...

class | Bitmap
A Map with one bit per pixel. More...

class | BlendAttribute
StateAttribute that determines the blending modes to use. More...

class | Camera
Abstract base class for parallel and perspective cameras. 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 | CullData
Class holding culling information of an object and it's children. More...

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 | FramedAnimation
Template class of an Animation that holds a complete data set for each frame. More...

class | GeoNode
Class to hold a set of geometries. 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 | InterpolatedAnimation
Abstract base class for an interpolated Animation of type T. More...

class | LightSource
Abstract base class for all light sources. More...

class | LinearInterpolatedAnimation
An InterpolatedAnimation 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 | 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 | IndexMesh
class | Object
Serves as base class for all traversable objects. More...

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 | 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 | Bone
An internal helper class for SkinnedTriangles. More...

struct | Skin
Internal helper class for SkinnedTriangles. More...

class | SkinnedTriangles
Class representing a skinned Triangles. 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...

struct | TextureAttributeItem::TextureImageSpec
class | TextureAttribute
Texture attribute. More...

class | TextureImage
A texture image abstraction class. More...

struct | TextureImage::Image
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...

class | VertexAttributeSet
Class to hold one set of vertex attributes. More...

class | ViewState
The ViewState class encapsulates the view-specific states. More...

class | VNVector
A helper class for use in animation. More...

Typedefs

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 &)
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 std::vector< unsigned
int > 		IndexSet
Shortcut for a vector of indices as used in TriStrips and QuadStrips.

typedef unsigned long long | DataID
64-bit save DataID.

typedef unsigned int | VariantKey
Key to a specific StateVariant.

Enumerations

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 {
OC_INVALID = 0xFFFFFFFF, OC_OBJECT = 0, OC_NODE = OC_OBJECT, OC_GEONODE,
OC_GROUP, OC_LOD, OC_SWITCH, OC_TRANSFORM,
OC_ANIMATEDTRANSFORM, OC_DIRECTEDLIGHT, OC_POINTLIGHT, OC_SPOTLIGHT,
OC_BILLBOARD, OC_DRAWABLES = 0x20, OC_VERTEX_ATTRIBUTE_SET, OC_QUADS,
OC_ANIMATEDQUADS, OC_QUADSTRIPS, OC_TRIANGLES, OC_ANIMATEDTRIANGLES,
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_STATESET = 0x40, OC_STATEVARIANT,
OC_STATEPASS, OC_STATEATTRIBUTE, OC_CGFX, OC_FACEATTRIBUTE,
OC_MATERIAL, OC_TEXTUREATTRIBUTE, OC_TEXTUREATTRIBUTEITEM, OC_STATESETEXT,
OC_LINEATTRIBUTE, OC_POINTATTRIBUTE, OC_BLENDATTRIBUTE, OC_DEPTHATTRIBUTE,
OC_ANIMATION = 0x60, OC_FRAMEDTRAFOANIMATION, OC_FRAMEDVNVECTORANIMATION, OC_LINEARINTERPOLATEDTRAFOANIMATION,
OC_LINEARINTERPOLATEDVNVECTORANIMATION, 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 | 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
}
Texture environment mode. 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 }
Texture wrap mode. More...

enum | TextureMinFilterMode { TFM_MIN_NEAREST = 0, TFM_MIN_BILINEAR, TFM_MIN_TRILINEAR }
Texture minification mode. More...

enum | TextureMagFilterMode { TFM_MAG_NEAREST = 0, TFM_MAG_BILINEAR }
Texture magnification mode. More...

enum | TextureCoordType { TCT_CYLINDRICAL, TCT_PLANAR, TCT_SPHERICAL }
Type to specify the type of texture coordinate to generate. More...

Functions

NVSGERRORHANDLER * | nvsgSetErrorHandler (NVSGERRORHANDLER *newErrorHandler)
NVSG_API void | nvsgInitialize (bool runInMultithreadedEnvironment=false)
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.

template<typename T> bool | isTypeOf (const Object *p)
Detects if the object pointed to by p is a pointer to a specified (templated) type.

bool | areOfSameType (const Object &p0, const Object &p1)
Detects if the two objects p0 and p1 are of the same type.

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 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 std::vector<unsigned int> IndexSet

Shortcut for a vector of indices as used in TriStrips and QuadStrips.

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 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_LOD | LOD.
OC_SWITCH | Switch.
OC_TRANSFORM | Transform.
OC_ANIMATEDTRANSFORM | AnimatedTransform.
OC_DIRECTEDLIGHT | DirectedLight.
OC_POINTLIGHT | PointLight.
OC_SPOTLIGHT | SpotLight.
OC_BILLBOARD | Billboard.
OC_DRAWABLES | Drawable = 0x20.
OC_VERTEX_ATTRIBUTE_SET | VertexAttributeSet.
OC_QUADS | Quads.
OC_ANIMATEDQUADS | AnimatedQuads.
OC_QUADSTRIPS | QuadStrips.
OC_TRIANGLES | Triangles.
OC_ANIMATEDTRIANGLES | AnimatedTriangles.
OC_SKINNEDTRIANGLES | SkinnedTriangles.
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_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_POINTATTRIBUTE | PointAttribute.
OC_BLENDATTRIBUTE | BlendAttribute.
OC_DEPTHATTRIBUTE | DepthAttribute.
OC_ANIMATION | Animation = 0x60.
OC_FRAMEDTRAFOANIMATION | FramedTrafoAnimation.
OC_FRAMEDVNVECTORANIMATION | FramedVectorAnimation.
OC_LINEARINTERPOLATEDTRAFOANIMATION | LinearAnimatedTrafoAnimation.
OC_LINEARINTERPOLATEDVNVECTORANIMATION | LinearInterpolatedVNVectorAnimation.
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.

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 | Corresponds to GL_MIRRORED_REPEAT_ARB in OpenGL.

enum TextureMinFilterMode

Texture minification mode.

Enumeration values:
TFM_MIN_NEAREST | Corresponds to GL_NEAREST in OpenGL.
TFM_MIN_BILINEAR | Corresponds to GL_LINEAR in OpenGL.
TFM_MIN_TRILINEAR | Corresponds to GL_LINEAR_MIPMAP_LINEAR in OpenGL.

enum TextureMagFilterMode

Texture magnification mode.

Enumeration values:
TFM_MAG_NEAREST | Corresponds to GL_NEAREST in OpenGL.
TFM_MAG_BILINEAR | Corresponds to GL_LINEAR in OpenGL.

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

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.

NVSG_API void nvsgInitialize ( bool runInMultithreadedEnvironment = false )

Per-application initialization of NVSG global data.

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 true for the optional runInMultithreadedEnvironment parameter. For a singlethreaded environment, it is strongly recommended to either omit this parameter, or to specify false here. Making the NVSG library multithreaded safe requires some overhead, which might affect the runtime behavior in a singlethreaded environment.

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.
Parameters:
runInMultithreadedEnvironment Specifies whether to run in a multithreaded environment, or not. Specify false when running in a singlethreaded environment, true when running in a multithreaded environment.

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

bool isTypeOf ( const Object * 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 | ( | const Object & | p0,
 |  | const Object & | 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.

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 Fri Aug 4 08:37:28 2006 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
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 | 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 | CullTraverser
Base class for culling parts of a scene. More...

class | DestrippingTraverser
Traverser to destripify stripped primitives. More...

class | FrustumCullTraverser
CullTraverser culling on frustum information. More...

class | GeoNodeCombineTraverser
Traverser that combines multiple GeoNodes under one Group to a single one. More...

class | GeoNodeUnifyTraverser
Optimizing Traverser that unifies GeoNodes. More...

class | GLTraverser
RenderTraverser using OpenGL. More...

class | GLTraverser::StipplePatterns
class | GroupEliminateTraverser
Traverser that eliminates unneccessary Groups. More...

class | IdentityToGroupTraverser
Traverser that replaces identity transforms by groups. More...

class | LODCombineTraverser
Traverser that combines LODS with the same ranges under one Group or Transform to a single one. More...

class | LODEliminateTraverser
Traverser that eliminates unneccessary LODs. More...

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

class | NormalizeTraverser
Traverser that normalizes all normals. More...

class | OptimizeTraverser
Base for Traversers that perform some optimizations on a scene. More...

class | PrimitiveSetCombineTraverser
Optimizing Traverser that combines PrimitiveSets under one GeoNode. More...

class | PrimitiveSetUnifyTraverser
Optimzing Traverser that unifies PrimitiveSets. More...

class | Intersection
Intersection class. More...

class | RayIntersectTraverser
RayIntersectTraverser. More...

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 | StateSetUnifyTraverser
Traverser that unifies identical StateSets. More...

class | StrippingTraverser
Traverser to convert Triangles to TriStrips, and Quads to QuadStrips. More...

class | SwitchToGroupTraverser
Traverser that replaces Switch objects by Group objects holding the active children only. More...

class | TransformCombineTraverser
Traverser that combines identical Transforms. More...

class | Traverser
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 | VertexAttributeSetUnifyTraverser
Optimizing Traverser that unifies VertexAttributeSets. More...

class | VertexUnifyTraverser
Traverser that can unifies vertices. More...

Enumerations

enum | { RT_GL = 0x00010000, RT_DX8 = 0x00020000, RT_DX9 = 0x00040000 }

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.

Generated on Fri Aug 4 08:39:03 2006 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...

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.

Generated on Fri Aug 4 08:39:53 2006 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...

class | IAllocator
An allocator interface. More...

class | Bit
Template class for easy definition of a single-bit bitmask. More...

class | Incarnation
This class abstracts an incarnation count. More...

class | Lockable
The Lockable class allows to add the SWMRSync feature to a non SWMRSync derived class. 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::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...

class | PointerReference
Provides reference counting for pointers. 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
class | ISWMRSync
Single write, multiple read synchronization interface. 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...

Typedefs

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 Singleton< Log< TM_BENCH_TEST,
logFileOutput > > 		LogBenchTest
Dedicated type for benchmark test logging.

typedef Singleton< Log< TM_SHADER_TEST,
logFileOutput > > 		LogShaderTest
Dedicated type for shader 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

Enumerations

enum | TESTMODE { TM_NONE = 0, TM_TEST, TM_BENCH_TEST, TM_SHADER_TEST }
Test modes available for logging. More...

Functions

NVSG_API void | AssertionFailed (const char *assertion, const char *file, unsigned int line, const char *function)
template<typename T> Lockable< T > & | beginEdit (const Lockable< T > &ref)
template<typename T> const Lockable< T > & | endEdit (Lockable< T > &ref)
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)
template<typename T> void | writeAccess (RCPtr< T > &rcPtr)
template<typename T> void | writeAccess (RCIPtr< T > &rcPtr)
NVSG_API void | EnableLocking ()
NVSG_API bool | WaitToWrite (const ISWMRSync *obj)
NVSG_API void | DoneWriting (const ISWMRSync *obj)
NVSG_API bool | WaitToRead (const ISWMRSync *obj)
NVSG_API void | DoneReading (const ISWMRSync *obj)
template<typename T> T * | beginEdit (const T *obj)
Initiates a safe edit operation on an ISWMRSync object.

template<typename T> const T * | endEdit (T *&obj)
Ends an edit operation on an ISWMRSync object.

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 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 | 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 bool | GetCurrentDir (std::string &path)
Get the current directory for the current process.

template<typename T> T | Maximum (T a, T b, T c)
template<typename T> T | Minimum (T a, T b, T c)
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

T* beginEdit ( const T * obj ) [inline]

Initiates a safe edit operation on an ISWMRSync object.

The function returns when the calling thread successfully obtained write access to the object. If the object is currently locked for write or read access from a concurrent thread, the calling thread enters the wait state. It uses no processor time while waiting to obtain write access.

After getting write access to the object, the function returns a pointer to the non-const object. Throught this pointer, the const and especially the non-const interface of the object can be accessed.

When the function returns, the object is protected against any write or read access from concurrent threads. After the desired edit operation has been completed, the write lock for the object must be released through a corresponding call to endEdit . Missing the endEdit call after completing the edit operation can cause the system to become deadlocked!

Returns:
A pointer to the now writable object.
Note:
The behavior is undefined if called with an invalid pointer.
Parameters:
obj Specifies the object for which write access is requested.

const T* endEdit ( T *& obj ) [inline]

Ends an edit operation on an ISWMRSync object.

The function ends an edit operation that previously has been initiated through a call to beginEdit .

The function must be called with the pointer to the non-const object, that has been returned by the matching call to beginEdit. The write lock for the object will be released and the function returns a pointer to the const object, through which only the const interface of the object could be utilized.

Immediately after the call, the passed pointer to the non-const object becomes invalid. Hence, using the pointer to the non-const object after this call leads to undefined behavior!

Returns:
A pointer to the non-const object, which is not writable anymore.
Note:
The behavior is undefined if called with an invalid pointer.
Parameters:
obj Specifies the object for which write access should be released.

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 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 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 Fri Aug 4 08:40:07 2006 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 Fri Aug 4 08:40:21 2006 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 Fri Aug 4 08:40:21 2006 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.

typedef Singleton< Log< TM_BENCH_TEST,
logFileOutput > > 		nvutil::LogBenchTest
Dedicated type for benchmark test logging.

typedef Singleton< Log< TM_SHADER_TEST,
logFileOutput > > 		nvutil::LogShaderTest
Dedicated type for shader test logging.

Enumerations

enum | nvutil::TESTMODE { nvutil::TM_NONE = 0, nvutil::TM_TEST, nvutil::TM_BENCH_TEST, nvutil::TM_SHADER_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.

typedef Singleton< Log<TM_BENCH_TEST, logFileOutput> > LogBenchTest

Dedicated type for benchmark test logging.

typedef Singleton< Log<TM_SHADER_TEST, logFileOutput> > LogShaderTest

Dedicated type for shader 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.
TM_BENCH_TEST | Bench test relevant logging.
TM_SHADER_TEST | Shader test relevant logging.

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 Fri Aug 4 08:37:11 2006 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.

#define | NVSG_LOG_BENCH_TEST_INIT(TM) nvutil::LogBenchTest::instance()->init(TM==nvutil::TM_BENCH_TEST)
Initialize benchmark test logging.

#define | NVSG_LOG_SHADER_TEST_INIT(TM) nvutil::LogShaderTest::instance()->init(TM==nvutil::TM_SHADER_TEST)
Ininialize shader 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_BENCH_TEST_INIT(testmode)  // enable bench test looging if testmode==TM_BENCH_TEST
 NVSG_LOG_SHADER_TEST_INIT(testmode) // enable shader test logging if testmode==TM_SHADER_TEST

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.

#define NVSG_LOG_BENCH_TEST_INIT ( TM ) nvutil::LogBenchTest::instance()->init(TM==nvutil::TM_BENCH_TEST)

Initialize benchmark test logging.

Enables benchmark test logging if TM equals TM_BENCH_TEST.

#define NVSG_LOG_SHADER_TEST_INIT ( TM ) nvutil::LogShaderTest::instance()->init(TM==nvutil::TM_SHADER_TEST)

Ininialize shader test logging.

Enables shader test logging if TM equals TM_SHADER_TEST.

Generated on Fri Aug 4 08:37:11 2006 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.

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

#define | NVSG_LOG_SHADER_TEST(s) { if ( nvutil::LogShaderTest::instance()->isEnabled() ) { nvutil::LogShaderTest::instance()->format s; } }
Output shader 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_SHADER_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.

#define NVSG_LOG_BENCH_TEST ( s ) { if ( nvutil::LogBenchTest::instance()->isEnabled() ) { nvutil::LogBenchTest::instance()->format s; } }

Output benchmark test relevant format string s if output is enabled.

#define NVSG_LOG_SHADER_TEST ( s ) { if ( nvutil::LogShaderTest::instance()->isEnabled() ) { nvutil::LogShaderTest::instance()->format s; } }

Output shader test relevant format string s if output is enabled.

Generated on Fri Aug 4 08:37:11 2006 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.

#define | NVSG_LOG_BENCH_TEST_ENABLED() nvutil::LogBenchTest::instance()->isEnabled()
Query if benchmark test is enabled.

#define | NVSG_LOG_SHADER_TEST_ENABLED() nvutil::LogShaderTest::instance()->isEnabled()
Query if shader test is enabled.

Detailed Description

This macros all can be used in conditional statements:
 if ( NVSG_LOG_BENCH_TEST_ENABLED() )
 {
    // ...
 }

Define Documentation

#define NVSG_LOG_TEST_ENABLED ( ) nvutil::LogTest::instance()->isEnabled()

Query if any test is enabled.

#define NVSG_LOG_BENCH_TEST_ENABLED ( ) nvutil::LogBenchTest::instance()->isEnabled()

Query if benchmark test is enabled.

#define NVSG_LOG_SHADER_TEST_ENABLED ( ) nvutil::LogShaderTest::instance()->isEnabled()

Query if shader test is enabled.

Generated on Fri Aug 4 08:37:11 2006 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines
b | f | g | i | m | n | o | q | r | t | u

Here is a list of all documented file members with links to the documentation:

- b -

  • byte_t : NBF.h

- f -

  • float2_t : NBF.h
  • float3_t : NBF.h
  • float4_t : NBF.h

- g -

  • GET_CURRENT_DC : GLContext.h
  • GET_CURRENT_RC : GLContext.h
  • getPlugInterface() : NVSGSaver.h, WRLLoader.h, NVSGLoader.h, NVBLoader.h

- i -

  • int_t : NBF.h

- m -

  • MAKE_CURRENT : GLContext.h

- n -

  • NBF_ANIMATED_QUADS : NBF.h
  • NBF_ANIMATED_TRANSFORM : NBF.h
  • NBF_ANIMATED_TRIANGLES : 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_FRAMED_TRAFO_ANIMATION : NBF.h
  • NBF_FRAMED_VNVECTOR_ANIMATION : NBF.h
  • NBF_GEO_NODE : NBF.h
  • NBF_GROUP : 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_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_VER_BUGFIX : NBF.h
  • NBF_VER_MAJOR : NBF.h
  • NBF_VER_MINOR : NBF.h
  • NBF_VERTEX_ATTRIBUTE_SET : NBF.h
  • NVSG_ASSERT_CONTEXT : GLTraverser.h
  • NVSG_CTASSERT() : NBF.h
  • NVSG_LOG_BENCH_TEST : Log.h
  • NVSG_LOG_BENCH_TEST_ENABLED : Log.h
  • NVSG_LOG_BENCH_TEST_INIT : Log.h
  • NVSG_LOG_FILE : Log.h
  • NVSG_LOG_SHADER_TEST : Log.h
  • NVSG_LOG_SHADER_TEST_ENABLED : Log.h
  • NVSG_LOG_SHADER_TEST_INIT : Log.h
  • NVSG_LOG_TEST : Log.h
  • NVSG_LOG_TEST_ENABLED : Log.h
  • NVSG_LOG_TEST_INIT : Log.h

- o -

  • operator new() : DbgNew.h
  • operator new[]() : DbgNew.h

- q -

  • queryPlugInterfaceType() : NVSGSaver.h, WRLLoader.h, NVSGLoader.h, NVBLoader.h

- r -

  • REG_NV_TRACE_SUBKEY : Trace.h

- t -

  • TRACE_LOG_FILE : Trace.h

- u -

  • ubyte_t : NBF.h
  • uint64_t : NBF.h
  • uint_t : NBF.h
  • UPITID_SCENE_LOADER : PlugInterfaceID.h
  • UPITID_SCENE_SAVER : PlugInterfaceID.h
  • UPITID_TEXTURE_LOADER : PlugInterfaceID.h
  • UPITID_VERSION : PlugInterfaceID.h
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • GET_CURRENT_DC : GLContext.h
  • GET_CURRENT_RC : GLContext.h
  • MAKE_CURRENT : GLContext.h
  • NVSG_ASSERT_CONTEXT : GLTraverser.h
  • NVSG_LOG_BENCH_TEST : Log.h
  • NVSG_LOG_BENCH_TEST_ENABLED : Log.h
  • NVSG_LOG_BENCH_TEST_INIT : Log.h
  • NVSG_LOG_SHADER_TEST : Log.h
  • NVSG_LOG_SHADER_TEST_ENABLED : Log.h
  • NVSG_LOG_SHADER_TEST_INIT : Log.h
  • NVSG_LOG_TEST : Log.h
  • NVSG_LOG_TEST_ENABLED : Log.h
  • NVSG_LOG_TEST_INIT : Log.h
  • TRACE_LOG_FILE : Trace.h
  • UPITID_SCENE_LOADER : PlugInterfaceID.h
  • UPITID_SCENE_SAVER : PlugInterfaceID.h
  • UPITID_TEXTURE_LOADER : PlugInterfaceID.h
  • UPITID_VERSION : PlugInterfaceID.h
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines
n

- n -

  • NBF_ANIMATED_QUADS : NBF.h
  • NBF_ANIMATED_TRANSFORM : NBF.h
  • NBF_ANIMATED_TRIANGLES : 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_FRAMED_TRAFO_ANIMATION : NBF.h
  • NBF_FRAMED_VNVECTOR_ANIMATION : NBF.h
  • NBF_GEO_NODE : NBF.h
  • NBF_GROUP : 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_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_VERTEX_ATTRIBUTE_SET : NBF.h
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • getPlugInterface() : NVSGSaver.h, WRLLoader.h, NVSGLoader.h, NVBLoader.h
  • NVSG_CTASSERT() : NBF.h
  • operator new() : DbgNew.h
  • operator new[]() : DbgNew.h
  • queryPlugInterfaceType() : NVSGSaver.h, WRLLoader.h, NVSGLoader.h, NVBLoader.h
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


File Member Index

All | Functions | Variables | Typedefs | Enumeration values | Defines

  • byte_t : NBF.h
  • float2_t : NBF.h
  • float3_t : NBF.h
  • float4_t : NBF.h
  • int_t : NBF.h
  • ubyte_t : NBF.h
  • uint64_t : NBF.h
  • uint_t : NBF.h
Generated on Fri Aug 4 08:40:21 2006 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 Fri Aug 4 08:40:21 2006 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 -

  • areOfSameType() : nvsg

- b -

  • beginEdit() : nvutil
  • 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

- c -

  • CC_IN : nvsg
  • CC_OUT : nvsg
  • CC_PART : nvsg
  • CgFxAnnotation : nvsg
  • CgFxParameter : nvsg
  • CgFxPass : nvsg
  • CgFxProgram : nvsg
  • CgFxTechnique : nvsg
  • cIdentity44f : nvmath
  • clamp() : nvmath
  • CullCode : nvsg
  • cUnitSphere : nvmath

- d -

  • DataID : nvsg
  • degToRad() : nvmath
  • DepthFunction : nvsg
  • DestroyCallback : nvutil

- e -

  • endEdit() : nvutil
  • equal3f() : nvgl
  • equal3fv() : nvgl
  • equal4f() : nvgl
  • equal4fv() : nvgl
  • equalf() : nvgl
  • errorMessage() : nvutil::IO

- f -

  • Face3 : nvsg
  • Face4 : nvsg
  • FileExists() : nvutil
  • FindFile() : nvutil
  • FindFileFirst() : nvutil

- g -

  • getCopyrightString() : nvsg
  • GetCurrentDir() : nvutil
  • GetDirFromPath() : nvutil
  • GetDrvAndDirFromPath() : nvutil
  • GetDrvFromPath() : nvutil
  • GetFileExtFromPath() : nvutil
  • GetFileNameFromPath() : nvutil
  • GetModulePath() : nvutil
  • getSDKName() : nvsg
  • getVendorName() : nvsg
  • getVersionString() : nvsg
  • GLAccum() : nvgl
  • GLActiveTexture() : nvgl
  • GLAlphaFunc() : nvgl
  • GLAreTexturesResident() : nvgl
  • GLArrayElement() : nvgl
  • GLBegin() : nvgl
  • GLBeginOcclusionQuery() : nvgl
  • GLBeginQuery() : nvgl
  • GLBindBuffer() : nvgl
  • GLBindIndexBuffer() : nvgl
  • GLBindProgram() : nvgl
  • GLBindTexture() : nvgl
  • GLBindVertexBuffer() : nvgl
  • GLBitmap() : nvgl
  • GLBlendFunc() : nvgl
  • GLBlendFuncSeparate() : nvgl
  • GLBufferData() : nvgl
  • GLBufferSubData() : nvgl
  • GLCallList() : nvgl
  • GLCallLists() : nvgl
  • GLClear() : nvgl
  • GLClearAccum() : nvgl
  • GLClearColor() : nvgl
  • GLClearDepth() : nvgl
  • GLClearIndex() : nvgl
  • GLClearStencil() : nvgl
  • GLClientActiveTexture() : nvgl
  • GLClipPlane() : nvgl
  • GLColor3b() : nvgl
  • GLColor3bv() : nvgl
  • GLColor3d() : nvgl
  • GLColor3dv() : nvgl
  • GLColor3f() : nvgl
  • GLColor3fv() : 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
  • GLColor4i() : nvgl
  • GLColor4iv() : nvgl
  • GLColor4s() : nvgl
  • GLColor4sv() : nvgl
  • GLColor4ub() : nvgl
  • GLColor4ubv() : nvgl
  • GLColor4ui() : nvgl
  • GLColor4uiv() : nvgl
  • GLColor4us() : nvgl
  • GLColor4usv() : nvgl
  • GLColorMask() : nvgl
  • GLColorMaterial() : nvgl
  • GLColorPointer() : nvgl
  • GLCompressedTexImage1D() : nvgl
  • GLCompressedTexImage2D() : nvgl
  • GLCompressedTexImage3D() : nvgl
  • GLCopyPixels() : nvgl
  • GLCopyTexImage1D() : nvgl
  • GLCopyTexImage2D() : nvgl
  • GLCopyTexSubImage1D() : nvgl
  • GLCopyTexSubImage2D() : nvgl
  • GLCullFace() : nvgl
  • GLDeleteBuffers() : nvgl
  • GLDeleteIndexBuffer() : nvgl
  • GLDeleteLists() : nvgl
  • GLDeleteOcclusionQueries() : nvgl
  • GLDeletePrograms() : nvgl
  • GLDeleteQueries() : nvgl
  • GLDeleteTextures() : nvgl
  • GLDeleteVertexBuffer() : nvgl
  • GLDepthFunc() : nvgl
  • GLDepthMask() : nvgl
  • GLDepthRange() : nvgl
  • GLDisable() : nvgl
  • GLDisableBlend() : nvgl
  • GLDisableClientState() : nvgl
  • GLDisableColorArray() : nvgl
  • GLDisableColorMaterial() : nvgl
  • GLDisableCullFace() : nvgl
  • GLDisableDepthTest() : nvgl
  • GLDisableFogCoordinateArray() : nvgl
  • GLDisableLighting() : nvgl
  • GLDisableLineSmooth() : nvgl
  • GLDisableLineStipple() : nvgl
  • GLDisableNormalArray() : nvgl
  • GLDisableNormalize() : nvgl
  • GLDisablePointSmooth() : nvgl
  • GLDisablePolygonOffsetFill() : nvgl
  • GLDisablePolygonOffsetLine() : nvgl
  • GLDisablePolygonOffsetPoint() : nvgl
  • GLDisablePolygonStipple() : nvgl
  • GLDisableSecondaryColorArray() : nvgl
  • GLDisableTexture() : nvgl
  • GLDisableTextureCoordArray() : nvgl
  • GLDisableTextureGen() : nvgl
  • GLDisableVertexArray() : nvgl
  • GLDrawArrays() : nvgl
  • GLDrawBuffer() : nvgl
  • GLDrawElements() : nvgl
  • GLDrawPixels() : nvgl
  • GLDrawRangeElements() : nvgl
  • GLEdgeFlag() : nvgl
  • GLEdgeFlagPointer() : nvgl
  • GLEdgeFlagv() : nvgl
  • GLEnable() : nvgl
  • GLEnableBlend() : nvgl
  • GLEnableClientState() : nvgl
  • GLEnableColorArray() : nvgl
  • GLEnableColorMaterial() : nvgl
  • GLEnableCullFace() : nvgl
  • GLEnableDepthTest() : nvgl
  • GLEnableFogCoordinateArray() : nvgl
  • GLEnableLighting() : nvgl
  • GLEnableLineSmooth() : nvgl
  • GLEnableLineStipple() : nvgl
  • GLEnableNormalArray() : nvgl
  • GLEnableNormalize() : nvgl
  • GLEnablePointSmooth() : nvgl
  • GLEnablePolygonOffsetFill() : nvgl
  • GLEnablePolygonOffsetLine() : nvgl
  • GLEnablePolygonOffsetPoint() : nvgl
  • GLEnablePolygonStipple() : nvgl
  • GLEnableSecondaryColorArray() : nvgl
  • GLEnableTexture() : nvgl
  • GLEnableTextureCoordArray() : nvgl
  • GLEnableTextureGen() : nvgl
  • GLEnableVertexArray() : nvgl
  • GLEnd() : nvgl
  • GLEndList() : nvgl
  • GLEndOcclusionQuery() : nvgl
  • GLEndQuery() : nvgl
  • glError : nvgl
  • GLEvalCoord1d() : nvgl
  • GLEvalCoord1f() : nvgl
  • GLEvalCoord2d() : nvgl
  • GLEvalCoord2f() : nvgl
  • GLEvalMesh1() : nvgl
  • GLEvalMesh2() : nvgl
  • GLEvalPoint1() : nvgl
  • GLEvalPoint2() : nvgl
  • GLFeedbackBuffer() : nvgl
  • GLFinish() : nvgl
  • GLFlush() : nvgl
  • GLFogCoordPointer() : nvgl
  • GLFogf() : nvgl
  • GLFogfv() : nvgl
  • GLFogi() : nvgl
  • GLFogiv() : nvgl
  • GLFrontFace() : nvgl
  • GLFrustum() : nvgl
  • GLGenBuffers() : nvgl
  • GLGenIndexBuffer() : nvgl
  • GLGenLists() : nvgl
  • GLGenOcclusionQueries() : nvgl
  • GLGenPrograms() : nvgl
  • GLGenQueries() : nvgl
  • GLGenTextures() : nvgl
  • GLGenVertexBuffer() : nvgl
  • GLGetBaseBufferOffset() : nvgl
  • GLGetBooleanv() : nvgl
  • GLGetClipPlane() : nvgl
  • GLGetDoublev() : nvgl
  • GLGetFloatv() : nvgl
  • GLGetIndexBufferOffset() : nvgl
  • GLGetIntegerv() : nvgl
  • GLGetLightfv() : nvgl
  • GLGetLightiv() : nvgl
  • GLGetMapdv() : nvgl
  • GLGetMapfv() : nvgl
  • GLGetMapiv() : nvgl
  • GLGetMaterialfv() : nvgl
  • GLGetMaterialiv() : nvgl
  • GLGetMaxTexCoords() : nvgl
  • GLGetMaxTexImageUnits() : nvgl
  • GLGetMaxTexUnits() : nvgl
  • GLGetOcclusionQueryuiv() : nvgl
  • GLGetPixelMapfv() : nvgl
  • GLGetPixelMapuiv() : nvgl
  • GLGetPixelMapusv() : nvgl
  • GLGetPointerv() : nvgl
  • GLGetPolygonStipple() : nvgl
  • GLGetQueryiv() : nvgl
  • GLGetQueryObjectiv() : nvgl
  • GLGetQueryObjectuiv() : nvgl
  • GLGetString() : nvgl
  • GLGetTexEnvfv() : nvgl
  • GLGetTexEnviv() : nvgl
  • GLGetTexGendv() : nvgl
  • GLGetTexGenfv() : nvgl
  • GLGetTexGeniv() : nvgl
  • GLGetTexImage() : nvgl
  • GLGetTexLevelParameterfv() : nvgl
  • GLGetTexLevelParameteriv() : nvgl
  • GLGetTexParameterfv() : nvgl
  • GLGetTexParameteriv() : nvgl
  • GLGetVertexBufferOffset() : nvgl
  • GLHint() : nvgl
  • GLIndexd() : nvgl
  • GLIndexf() : nvgl
  • GLIndexi() : nvgl
  • GLIndexMask() : nvgl
  • GLIndexPointer() : nvgl
  • GLIndexs() : nvgl
  • GLIndexub() : nvgl
  • GLInitNames() : nvgl
  • GLInterleavedArrays() : nvgl
  • GLintToGLfloat() : nvgl
  • GLIsBuffer() : nvgl
  • GLIsEnabled() : nvgl
  • GLIsExtensionAvailable() : nvgl
  • GLIsExtensionExported() : nvgl
  • GLIsIndexBuffer() : nvgl
  • GLIsList() : nvgl
  • GLIsOcclusionQuery() : nvgl
  • GLIsProgram() : nvgl
  • GLIsQuery() : 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
  • GLLightPosition() : nvgl
  • GLLightQuadraticAttenuation() : nvgl
  • GLLightSpecular() : nvgl
  • GLLightSpotCutoff() : nvgl
  • GLLightSpotDirection() : nvgl
  • GLLightSpotExponent() : nvgl
  • GLLineStipple() : nvgl
  • GLLineWidth() : nvgl
  • GLListBase() : nvgl
  • GLLoadIdentity() : nvgl
  • GLLoadMatrixd() : nvgl
  • GLLoadMatrixf() : nvgl
  • GLLoadName() : nvgl
  • GLLoadProgram() : nvgl
  • GLLoadTransposedMatrixd() : nvgl
  • GLLoadTransposeMatrixf() : 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
  • GLMultiDrawElements() : nvgl
  • GLMultiTexCoord2f() : nvgl
  • GLMultMatrixd() : nvgl
  • GLMultMatrixf() : nvgl
  • GLMultTransposeMatrixd() : nvgl
  • GLMultTransposeMatrixf() : nvgl
  • GLNewList() : nvgl
  • GLNormal3b() : nvgl
  • GLNormal3bv() : nvgl
  • GLNormal3d() : nvgl
  • GLNormal3dv() : nvgl
  • GLNormal3f() : nvgl
  • GLNormal3fv() : nvgl
  • GLNormal3i() : nvgl
  • GLNormal3iv() : nvgl
  • GLNormal3s() : nvgl
  • GLNormal3sv() : nvgl
  • GLNormalPointer() : nvgl
  • GLOrtho() : nvgl
  • GLPassThrough() : nvgl
  • GLPixelMapfv() : nvgl
  • GLPixelMapuiv() : nvgl
  • GLPixelMapusv() : nvgl
  • GLPixelStoref() : nvgl
  • GLPixelStorei() : nvgl
  • GLPixelTransferf() : nvgl
  • GLPixelTransferi() : nvgl
  • GLPixelZoom() : nvgl
  • GLPointSize() : nvgl
  • GLPolygonMode() : nvgl
  • GLPolygonModeBack() : nvgl
  • GLPolygonModeFront() : nvgl
  • GLPolygonModeFrontAndBack() : nvgl
  • GLPolygonOffset() : nvgl
  • GLPolygonStipple() : nvgl
  • GLPopAttrib() : nvgl
  • GLPopClientAttrib() : nvgl
  • GLPopMatrix() : nvgl
  • GLPopName() : nvgl
  • GLPrimitiveRestartIndex() : nvgl
  • GLPrioritizeTextures() : nvgl
  • GLProgramNamedParameter4f() : 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
  • GLRenderMode() : nvgl
  • GLRotated() : nvgl
  • GLRotatef() : nvgl
  • GLScaled() : nvgl
  • GLScalef() : nvgl
  • GLScissor() : nvgl
  • GLSecondaryColorPointer() : nvgl
  • GLSelectBuffer() : nvgl
  • GLSetWindowStereoMode() : nvgl
  • GLShadeModel() : nvgl
  • GLStencilFunc() : nvgl
  • GLStencilMask() : nvgl
  • GLStencilOp() : nvgl
  • GLTexCoord1d() : nvgl
  • GLTexCoord1f() : nvgl
  • GLTexCoord1i() : nvgl
  • GLTexCoord1s() : nvgl
  • GLTexCoord2d() : nvgl
  • GLTexCoord2f() : nvgl
  • GLTexCoord2fv() : nvgl
  • GLTexCoord2i() : nvgl
  • GLTexCoord2s() : nvgl
  • GLTexCoord3d() : nvgl
  • GLTexCoord3f() : nvgl
  • GLTexCoord3i() : nvgl
  • GLTexCoord3s() : nvgl
  • GLTexCoord4d() : nvgl
  • GLTexCoord4f() : nvgl
  • GLTexCoord4i() : nvgl
  • GLTexCoord4s() : 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
  • GLTexParameteriv() : nvgl
  • GLTexSubImage1D() : nvgl
  • GLTexSubImage2D() : nvgl
  • GLTextureBorderColor() : nvgl
  • GLTextureEnvColor() : nvgl
  • GLTextureEnvMode() : nvgl
  • GLTextureMagFilter() : nvgl
  • GLTextureMinFilter() : nvgl
  • GLTextureWrapR() : nvgl
  • GLTextureWrapS() : nvgl
  • GLTextureWrapT() : nvgl
  • GLTranslated() : nvgl
  • GLTranslatef() : nvgl
  • GLUnmapBuffer() : nvgl
  • GLUnmapIndexBuffer() : nvgl
  • GLUnmapVertexBuffer() : nvgl
  • GLUploadBuffers() : nvgl
  • GLVertex2d() : nvgl
  • GLVertex2f() : nvgl
  • GLVertex2i() : nvgl
  • GLVertex2s() : nvgl
  • GLVertex3d() : nvgl
  • GLVertex3f() : nvgl
  • GLVertex3fv() : nvgl
  • GLVertex3i() : nvgl
  • GLVertex3s() : nvgl
  • GLVertex4d() : nvgl
  • GLVertex4f() : nvgl
  • GLVertex4i() : nvgl
  • GLVertex4s() : nvgl
  • GLVertexPointer() : nvgl
  • GLViewport() : nvgl
  • GLXCreateContext() : nvgl
  • GLXDestroyContext() : nvgl
  • GLXGetCurrentContext() : nvgl
  • GLXGetCurrentDrawable() : nvgl

- h -

  • HDAL : nvsg
  • HDAL_INVALID : nvsg

- i -

  • IndexSet : nvsg
  • isPowerOfTwo() : nvmath
  • isTypeOf() : nvsg

- l -

  • lerp() : nvmath
  • LOG_OUTPUT_FUNCTION : nvutil
  • LogBenchTest : nvutil
  • logFileOutput : nvutil
  • LogShaderTest : nvutil
  • LogTest : nvutil

- m -

  • MA_CENTER : nvsg
  • MA_LOWER : nvsg
  • MA_UPPER : nvsg
  • MapAlignment : nvsg
  • MapOrientation : nvsg
  • MapRelation : nvsg
  • MapTraversalDirection : nvsg
  • MaterialFace : 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 -

  • nvsgErrorHandler : nvsg
  • NVSGERRORHANDLER : nvsg
  • nvsgInitialize() : nvsg
  • nvsgSetErrorHandler() : nvsg
  • nvsgTerminate() : nvsg

- o -

  • OC_ANIMATEDQUADS : nvsg
  • OC_ANIMATEDTRANSFORM : nvsg
  • OC_ANIMATEDTRIANGLES : 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_FRAMEDTRAFOANIMATION : nvsg
  • OC_FRAMEDVNVECTORANIMATION : nvsg
  • OC_GEONODE : nvsg
  • OC_GROUP : nvsg
  • OC_HIGHLIGHTBOX : nvsg
  • OC_HIGHLIGHTEDGES : nvsg
  • OC_HIGHLIGHTOBJECT : nvsg
  • OC_INVALID : nvsg
  • OC_LINEARINTERPOLATEDTRAFOANIMATION : nvsg
  • OC_LINEARINTERPOLATEDVNVECTORANIMATION : 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_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_VERTEX_ATTRIBUTE_SET : nvsg
  • operator!=() : nvutil
  • operator<() : nvutil
  • operator==() : nvutil

- p -

  • PFNGETPLUGINTERFACE : nvutil
  • PFNQUERYPLUGINTERFACETYPE : nvutil
  • PI : nvmath
  • PI_HALF : nvmath
  • PI_QUARTER : nvmath
  • PIS : nvutil
  • powerOfTwoBelow() : nvmath
  • ProblemLogList : nvutil

- r -

  • radToDeg() : nvmath

- s -

  • Segment : nvsg
  • SetCurrentDir() : nvutil
  • sign() : 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_BLEND : nvsg
  • TEM_DECAL : nvsg
  • TEM_MODULATE : nvsg
  • TEM_REPLACE : nvsg
  • TESTMODE : nvutil
  • TexCoordAxis : nvsg
  • TexGenLinearPlane : nvsg
  • TexGenMode : nvsg
  • TextureCoordType : nvsg
  • TextureEnvMode : nvsg
  • TextureMagFilterMode : nvsg
  • TextureMinFilterMode : nvsg
  • TextureWrapMode : nvsg
  • TexWrapCoordAxis : nvsg
  • TFM_MAG_BILINEAR : nvsg
  • TFM_MAG_NEAREST : nvsg
  • TFM_MIN_BILINEAR : nvsg
  • TFM_MIN_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_BENCH_TEST : nvutil
  • TM_NONE : nvutil
  • TM_SHADER_TEST : nvutil
  • TM_TEST : nvutil
  • TWCA_R : nvsg
  • TWCA_S : nvsg
  • TWCA_T : nvsg
  • TWM_CLAMP : nvsg
  • TWM_MIRROR : nvsg
  • TWM_REPEAT : nvsg

- v -

  • VariantKey : nvsg

- w -

  • WGLBindSwapBarrierNV() : nvgl
  • WGLBindTexImage() : nvgl
  • WGLChoosePixelFormat() : nvgl
  • WGLCreateContext() : nvgl
  • WGLCreatePbuffer() : nvgl
  • WGLDeleteContext() : nvgl
  • WGLDestroyPbuffer() : nvgl
  • WGLGetCurrentContext() : nvgl
  • WGLGetCurrentDC() : nvgl
  • WGLGetPbufferDC() : nvgl
  • WGLJoinSwapGroupNV() : nvgl
  • WGLQueryFrameCountNV() : nvgl
  • WGLQueryMaxSwapGroupsNV() : nvgl
  • WGLQueryPbuffer() : nvgl
  • WGLQuerySwapGroupNV() : nvgl
  • WGLReleasePbufferDC() : nvgl
  • WGLReleaseTexImage() : nvgl
  • WGLResetFrameCountNV() : nvgl
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values

  • 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
  • TextureMagFilterMode : nvsg
  • TextureMinFilterMode : nvsg
  • TextureWrapMode : nvsg
  • TexWrapCoordAxis : nvsg
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values
b | c | m | 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

- o -

  • OC_ANIMATEDQUADS : nvsg
  • OC_ANIMATEDTRANSFORM : nvsg
  • OC_ANIMATEDTRIANGLES : 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_FRAMEDTRAFOANIMATION : nvsg
  • OC_FRAMEDVNVECTORANIMATION : nvsg
  • OC_GEONODE : nvsg
  • OC_GROUP : nvsg
  • OC_HIGHLIGHTBOX : nvsg
  • OC_HIGHLIGHTEDGES : nvsg
  • OC_HIGHLIGHTOBJECT : nvsg
  • OC_INVALID : nvsg
  • OC_LINEARINTERPOLATEDTRAFOANIMATION : nvsg
  • OC_LINEARINTERPOLATEDVNVECTORANIMATION : 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_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_VERTEX_ATTRIBUTE_SET : 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_BLEND : nvsg
  • TEM_DECAL : nvsg
  • TEM_MODULATE : nvsg
  • TEM_REPLACE : nvsg
  • TFM_MAG_BILINEAR : nvsg
  • TFM_MAG_NEAREST : nvsg
  • TFM_MIN_BILINEAR : nvsg
  • TFM_MIN_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_BENCH_TEST : nvutil
  • TM_NONE : nvutil
  • TM_SHADER_TEST : nvutil
  • TM_TEST : nvutil
  • TWCA_R : nvsg
  • TWCA_S : nvsg
  • TWCA_T : nvsg
  • TWM_CLAMP : nvsg
  • TWM_MIRROR : nvsg
  • TWM_REPEAT : nvsg
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values
a | b | c | d | e | f | g | i | l | n | o | p | r | s | w

- a -

  • areOfSameType() : nvsg

- b -

  • beginEdit() : nvutil

- c -

  • clamp() : nvmath

- d -

  • degToRad() : nvmath

- e -

  • endEdit() : nvutil
  • equal3f() : nvgl
  • equal3fv() : nvgl
  • equal4f() : nvgl
  • equal4fv() : nvgl
  • equalf() : nvgl
  • errorMessage() : nvutil::IO

- f -

  • FileExists() : nvutil
  • FindFile() : nvutil
  • FindFileFirst() : nvutil

- g -

  • getCopyrightString() : nvsg
  • GetCurrentDir() : nvutil
  • GetDirFromPath() : nvutil
  • GetDrvAndDirFromPath() : nvutil
  • GetDrvFromPath() : nvutil
  • GetFileExtFromPath() : nvutil
  • GetFileNameFromPath() : nvutil
  • GetModulePath() : nvutil
  • getSDKName() : nvsg
  • getVendorName() : nvsg
  • getVersionString() : nvsg
  • GLAccum() : nvgl
  • GLActiveTexture() : nvgl
  • GLAlphaFunc() : nvgl
  • GLAreTexturesResident() : nvgl
  • GLArrayElement() : nvgl
  • GLBegin() : nvgl
  • GLBeginOcclusionQuery() : nvgl
  • GLBeginQuery() : nvgl
  • GLBindBuffer() : nvgl
  • GLBindIndexBuffer() : nvgl
  • GLBindProgram() : nvgl
  • GLBindTexture() : nvgl
  • GLBindVertexBuffer() : nvgl
  • GLBitmap() : nvgl
  • GLBlendFunc() : nvgl
  • GLBlendFuncSeparate() : nvgl
  • GLBufferData() : nvgl
  • GLBufferSubData() : nvgl
  • GLCallList() : nvgl
  • GLCallLists() : nvgl
  • GLClear() : nvgl
  • GLClearAccum() : nvgl
  • GLClearColor() : nvgl
  • GLClearDepth() : nvgl
  • GLClearIndex() : nvgl
  • GLClearStencil() : nvgl
  • GLClientActiveTexture() : nvgl
  • GLClipPlane() : nvgl
  • GLColor3b() : nvgl
  • GLColor3bv() : nvgl
  • GLColor3d() : nvgl
  • GLColor3dv() : nvgl
  • GLColor3f() : nvgl
  • GLColor3fv() : 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
  • GLColor4i() : nvgl
  • GLColor4iv() : nvgl
  • GLColor4s() : nvgl
  • GLColor4sv() : nvgl
  • GLColor4ub() : nvgl
  • GLColor4ubv() : nvgl
  • GLColor4ui() : nvgl
  • GLColor4uiv() : nvgl
  • GLColor4us() : nvgl
  • GLColor4usv() : nvgl
  • GLColorMask() : nvgl
  • GLColorMaterial() : nvgl
  • GLColorPointer() : nvgl
  • GLCompressedTexImage1D() : nvgl
  • GLCompressedTexImage2D() : nvgl
  • GLCompressedTexImage3D() : nvgl
  • GLCopyPixels() : nvgl
  • GLCopyTexImage1D() : nvgl
  • GLCopyTexImage2D() : nvgl
  • GLCopyTexSubImage1D() : nvgl
  • GLCopyTexSubImage2D() : nvgl
  • GLCullFace() : nvgl
  • GLDeleteBuffers() : nvgl
  • GLDeleteIndexBuffer() : nvgl
  • GLDeleteLists() : nvgl
  • GLDeleteOcclusionQueries() : nvgl
  • GLDeletePrograms() : nvgl
  • GLDeleteQueries() : nvgl
  • GLDeleteTextures() : nvgl
  • GLDeleteVertexBuffer() : nvgl
  • GLDepthFunc() : nvgl
  • GLDepthMask() : nvgl
  • GLDepthRange() : nvgl
  • GLDisable() : nvgl
  • GLDisableBlend() : nvgl
  • GLDisableClientState() : nvgl
  • GLDisableColorArray() : nvgl
  • GLDisableColorMaterial() : nvgl
  • GLDisableCullFace() : nvgl
  • GLDisableDepthTest() : nvgl
  • GLDisableFogCoordinateArray() : nvgl
  • GLDisableLighting() : nvgl
  • GLDisableLineSmooth() : nvgl
  • GLDisableLineStipple() : nvgl
  • GLDisableNormalArray() : nvgl
  • GLDisableNormalize() : nvgl
  • GLDisablePointSmooth() : nvgl
  • GLDisablePolygonOffsetFill() : nvgl
  • GLDisablePolygonOffsetLine() : nvgl
  • GLDisablePolygonOffsetPoint() : nvgl
  • GLDisablePolygonStipple() : nvgl
  • GLDisableSecondaryColorArray() : nvgl
  • GLDisableTexture() : nvgl
  • GLDisableTextureCoordArray() : nvgl
  • GLDisableTextureGen() : nvgl
  • GLDisableVertexArray() : nvgl
  • GLDrawArrays() : nvgl
  • GLDrawBuffer() : nvgl
  • GLDrawElements() : nvgl
  • GLDrawPixels() : nvgl
  • GLDrawRangeElements() : nvgl
  • GLEdgeFlag() : nvgl
  • GLEdgeFlagPointer() : nvgl
  • GLEdgeFlagv() : nvgl
  • GLEnable() : nvgl
  • GLEnableBlend() : nvgl
  • GLEnableClientState() : nvgl
  • GLEnableColorArray() : nvgl
  • GLEnableColorMaterial() : nvgl
  • GLEnableCullFace() : nvgl
  • GLEnableDepthTest() : nvgl
  • GLEnableFogCoordinateArray() : nvgl
  • GLEnableLighting() : nvgl
  • GLEnableLineSmooth() : nvgl
  • GLEnableLineStipple() : nvgl
  • GLEnableNormalArray() : nvgl
  • GLEnableNormalize() : nvgl
  • GLEnablePointSmooth() : nvgl
  • GLEnablePolygonOffsetFill() : nvgl
  • GLEnablePolygonOffsetLine() : nvgl
  • GLEnablePolygonOffsetPoint() : nvgl
  • GLEnablePolygonStipple() : nvgl
  • GLEnableSecondaryColorArray() : nvgl
  • GLEnableTexture() : nvgl
  • GLEnableTextureCoordArray() : nvgl
  • GLEnableTextureGen() : nvgl
  • GLEnableVertexArray() : nvgl
  • GLEnd() : nvgl
  • GLEndList() : nvgl
  • GLEndOcclusionQuery() : nvgl
  • GLEndQuery() : nvgl
  • GLEvalCoord1d() : nvgl
  • GLEvalCoord1f() : nvgl
  • GLEvalCoord2d() : nvgl
  • GLEvalCoord2f() : nvgl
  • GLEvalMesh1() : nvgl
  • GLEvalMesh2() : nvgl
  • GLEvalPoint1() : nvgl
  • GLEvalPoint2() : nvgl
  • GLFeedbackBuffer() : nvgl
  • GLFinish() : nvgl
  • GLFlush() : nvgl
  • GLFogCoordPointer() : nvgl
  • GLFogf() : nvgl
  • GLFogfv() : nvgl
  • GLFogi() : nvgl
  • GLFogiv() : nvgl
  • GLFrontFace() : nvgl
  • GLFrustum() : nvgl
  • GLGenBuffers() : nvgl
  • GLGenIndexBuffer() : nvgl
  • GLGenLists() : nvgl
  • GLGenOcclusionQueries() : nvgl
  • GLGenPrograms() : nvgl
  • GLGenQueries() : nvgl
  • GLGenTextures() : nvgl
  • GLGenVertexBuffer() : nvgl
  • GLGetBaseBufferOffset() : nvgl
  • GLGetBooleanv() : nvgl
  • GLGetClipPlane() : nvgl
  • GLGetDoublev() : nvgl
  • GLGetFloatv() : nvgl
  • GLGetIndexBufferOffset() : nvgl
  • GLGetIntegerv() : nvgl
  • GLGetLightfv() : nvgl
  • GLGetLightiv() : nvgl
  • GLGetMapdv() : nvgl
  • GLGetMapfv() : nvgl
  • GLGetMapiv() : nvgl
  • GLGetMaterialfv() : nvgl
  • GLGetMaterialiv() : nvgl
  • GLGetMaxTexCoords() : nvgl
  • GLGetMaxTexImageUnits() : nvgl
  • GLGetMaxTexUnits() : nvgl
  • GLGetOcclusionQueryuiv() : nvgl
  • GLGetPixelMapfv() : nvgl
  • GLGetPixelMapuiv() : nvgl
  • GLGetPixelMapusv() : nvgl
  • GLGetPointerv() : nvgl
  • GLGetPolygonStipple() : nvgl
  • GLGetQueryiv() : nvgl
  • GLGetQueryObjectiv() : nvgl
  • GLGetQueryObjectuiv() : nvgl
  • GLGetString() : nvgl
  • GLGetTexEnvfv() : nvgl
  • GLGetTexEnviv() : nvgl
  • GLGetTexGendv() : nvgl
  • GLGetTexGenfv() : nvgl
  • GLGetTexGeniv() : nvgl
  • GLGetTexImage() : nvgl
  • GLGetTexLevelParameterfv() : nvgl
  • GLGetTexLevelParameteriv() : nvgl
  • GLGetTexParameterfv() : nvgl
  • GLGetTexParameteriv() : nvgl
  • GLGetVertexBufferOffset() : nvgl
  • GLHint() : nvgl
  • GLIndexd() : nvgl
  • GLIndexf() : nvgl
  • GLIndexi() : nvgl
  • GLIndexMask() : nvgl
  • GLIndexPointer() : nvgl
  • GLIndexs() : nvgl
  • GLIndexub() : nvgl
  • GLInitNames() : nvgl
  • GLInterleavedArrays() : nvgl
  • GLintToGLfloat() : nvgl
  • GLIsBuffer() : nvgl
  • GLIsEnabled() : nvgl
  • GLIsExtensionAvailable() : nvgl
  • GLIsExtensionExported() : nvgl
  • GLIsIndexBuffer() : nvgl
  • GLIsList() : nvgl
  • GLIsOcclusionQuery() : nvgl
  • GLIsProgram() : nvgl
  • GLIsQuery() : 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
  • GLLightPosition() : nvgl
  • GLLightQuadraticAttenuation() : nvgl
  • GLLightSpecular() : nvgl
  • GLLightSpotCutoff() : nvgl
  • GLLightSpotDirection() : nvgl
  • GLLightSpotExponent() : nvgl
  • GLLineStipple() : nvgl
  • GLLineWidth() : nvgl
  • GLListBase() : nvgl
  • GLLoadIdentity() : nvgl
  • GLLoadMatrixd() : nvgl
  • GLLoadMatrixf() : nvgl
  • GLLoadName() : nvgl
  • GLLoadProgram() : nvgl
  • GLLoadTransposedMatrixd() : nvgl
  • GLLoadTransposeMatrixf() : 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
  • GLMultiDrawElements() : nvgl
  • GLMultiTexCoord2f() : nvgl
  • GLMultMatrixd() : nvgl
  • GLMultMatrixf() : nvgl
  • GLMultTransposeMatrixd() : nvgl
  • GLMultTransposeMatrixf() : nvgl
  • GLNewList() : nvgl
  • GLNormal3b() : nvgl
  • GLNormal3bv() : nvgl
  • GLNormal3d() : nvgl
  • GLNormal3dv() : nvgl
  • GLNormal3f() : nvgl
  • GLNormal3fv() : nvgl
  • GLNormal3i() : nvgl
  • GLNormal3iv() : nvgl
  • GLNormal3s() : nvgl
  • GLNormal3sv() : nvgl
  • GLNormalPointer() : nvgl
  • GLOrtho() : nvgl
  • GLPassThrough() : nvgl
  • GLPixelMapfv() : nvgl
  • GLPixelMapuiv() : nvgl
  • GLPixelMapusv() : nvgl
  • GLPixelStoref() : nvgl
  • GLPixelStorei() : nvgl
  • GLPixelTransferf() : nvgl
  • GLPixelTransferi() : nvgl
  • GLPixelZoom() : nvgl
  • GLPointSize() : nvgl
  • GLPolygonMode() : nvgl
  • GLPolygonModeBack() : nvgl
  • GLPolygonModeFront() : nvgl
  • GLPolygonModeFrontAndBack() : nvgl
  • GLPolygonOffset() : nvgl
  • GLPolygonStipple() : nvgl
  • GLPopAttrib() : nvgl
  • GLPopClientAttrib() : nvgl
  • GLPopMatrix() : nvgl
  • GLPopName() : nvgl
  • GLPrimitiveRestartIndex() : nvgl
  • GLPrioritizeTextures() : nvgl
  • GLProgramNamedParameter4f() : 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
  • GLRenderMode() : nvgl
  • GLRotated() : nvgl
  • GLRotatef() : nvgl
  • GLScaled() : nvgl
  • GLScalef() : nvgl
  • GLScissor() : nvgl
  • GLSecondaryColorPointer() : nvgl
  • GLSelectBuffer() : nvgl
  • GLSetWindowStereoMode() : nvgl
  • GLShadeModel() : nvgl
  • GLStencilFunc() : nvgl
  • GLStencilMask() : nvgl
  • GLStencilOp() : nvgl
  • GLTexCoord1d() : nvgl
  • GLTexCoord1f() : nvgl
  • GLTexCoord1i() : nvgl
  • GLTexCoord1s() : nvgl
  • GLTexCoord2d() : nvgl
  • GLTexCoord2f() : nvgl
  • GLTexCoord2fv() : nvgl
  • GLTexCoord2i() : nvgl
  • GLTexCoord2s() : nvgl
  • GLTexCoord3d() : nvgl
  • GLTexCoord3f() : nvgl
  • GLTexCoord3i() : nvgl
  • GLTexCoord3s() : nvgl
  • GLTexCoord4d() : nvgl
  • GLTexCoord4f() : nvgl
  • GLTexCoord4i() : nvgl
  • GLTexCoord4s() : 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
  • GLTexParameteriv() : nvgl
  • GLTexSubImage1D() : nvgl
  • GLTexSubImage2D() : nvgl
  • GLTextureBorderColor() : nvgl
  • GLTextureEnvColor() : nvgl
  • GLTextureEnvMode() : nvgl
  • GLTextureMagFilter() : nvgl
  • GLTextureMinFilter() : nvgl
  • GLTextureWrapR() : nvgl
  • GLTextureWrapS() : nvgl
  • GLTextureWrapT() : nvgl
  • GLTranslated() : nvgl
  • GLTranslatef() : nvgl
  • GLUnmapBuffer() : nvgl
  • GLUnmapIndexBuffer() : nvgl
  • GLUnmapVertexBuffer() : nvgl
  • GLUploadBuffers() : nvgl
  • GLVertex2d() : nvgl
  • GLVertex2f() : nvgl
  • GLVertex2i() : nvgl
  • GLVertex2s() : nvgl
  • GLVertex3d() : nvgl
  • GLVertex3f() : nvgl
  • GLVertex3fv() : nvgl
  • GLVertex3i() : nvgl
  • GLVertex3s() : nvgl
  • GLVertex4d() : nvgl
  • GLVertex4f() : nvgl
  • GLVertex4i() : nvgl
  • GLVertex4s() : nvgl
  • GLVertexPointer() : nvgl
  • GLViewport() : nvgl
  • GLXCreateContext() : nvgl
  • GLXDestroyContext() : nvgl
  • GLXGetCurrentContext() : nvgl
  • GLXGetCurrentDrawable() : nvgl

- i -

  • isPowerOfTwo() : nvmath
  • isTypeOf() : nvsg

- l -

  • lerp() : nvmath

- n -

  • nvsgInitialize() : nvsg
  • nvsgSetErrorHandler() : nvsg
  • nvsgTerminate() : nvsg

- o -

  • operator!=() : nvutil
  • operator<() : nvutil
  • operator==() : nvutil

- p -

  • powerOfTwoBelow() : nvmath

- r -

  • radToDeg() : nvmath

- s -

  • SetCurrentDir() : nvutil
  • sign() : nvmath
  • square() : nvmath

- w -

  • WGLBindSwapBarrierNV() : nvgl
  • WGLBindTexImage() : nvgl
  • WGLChoosePixelFormat() : nvgl
  • WGLCreateContext() : nvgl
  • WGLCreatePbuffer() : nvgl
  • WGLDeleteContext() : nvgl
  • WGLDestroyPbuffer() : nvgl
  • WGLGetCurrentContext() : nvgl
  • WGLGetCurrentDC() : nvgl
  • WGLGetPbufferDC() : nvgl
  • WGLJoinSwapGroupNV() : nvgl
  • WGLQueryFrameCountNV() : nvgl
  • WGLQueryMaxSwapGroupsNV() : nvgl
  • WGLQueryPbuffer() : nvgl
  • WGLQuerySwapGroupNV() : nvgl
  • WGLReleasePbufferDC() : nvgl
  • WGLReleaseTexImage() : nvgl
  • WGLResetFrameCountNV() : nvgl
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values

  • CgFxAnnotation : nvsg
  • CgFxParameter : nvsg
  • CgFxPass : nvsg
  • CgFxProgram : nvsg
  • CgFxTechnique : nvsg
  • DataID : nvsg
  • DestroyCallback : nvutil
  • Face3 : nvsg
  • Face4 : nvsg
  • HDAL : nvsg
  • IndexSet : nvsg
  • LOG_OUTPUT_FUNCTION : nvutil
  • LogBenchTest : nvutil
  • LogShaderTest : nvutil
  • LogTest : nvutil
  • NVSGERRORHANDLER : nvsg
  • PFNGETPLUGINTERFACE : nvutil
  • PFNQUERYPLUGINTERFACETYPE : nvutil
  • PIS : nvutil
  • ProblemLogList : nvutil
  • Segment : nvsg
  • VariantKey : nvsg
Generated on Fri Aug 4 08:40:21 2006 for NVSGSDK by NVIDIA


Namespace Member Index

All | Functions | Variables | Typedefs | Enumerations | Enumeration values

  • cIdentity44f : nvmath
  • cUnitSphere : 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 Fri Aug 4 08:40:21 2006 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
  • 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 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
  • Memory Management
  • Working with Multitexturing
  • Important Concepts - Must Read for All Developers
  • NVSG Core Classes
  • NVSG Objects
  • Overview of the Principal Classes
  • Recommended Reading
  • Separation of Data from Their Operations
  • 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
  • Writing a Loader/Saver Plug-In
Generated on Fri Aug 4 08:40:21 2006 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 Fri Aug 4 08:37:09 2006 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 Fri Aug 4 08:37:09 2006 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\$(ConfigurationName)"

Additional libs (Input / Additional Dependencies):

  • opengl32.lib
  • ramfc.lib
  • nvsg.lib

DLL Requirements

  • nvsg1.dll
  • ramfc1.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 Fri Aug 4 08:37:09 2006 for NVSGSDK by NVIDIA


Creating a New Plug-in Project

A plug-in is always provided as a dynaming link library (DLL). 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\$(ConfigurationName)"

Additional libs (Input / Additional Dependencies):

  • nvsg.lib

See also the EXRLoader tutorial for further information.

Back to Advanced

Generated on Fri Aug 4 08:37:09 2006 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 Fri Aug 4 08:37:09 2006 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 set up a CgFx effect loaded from a file?
  • How do I set up a CgFX effect from lump?
  • 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?
  • 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
  • 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".

const Node * CSimpleViewerDoc::createSimpleTree() const
{
  Trafo rootTrafo;
  rootTrafo.setOrientation( Quatf(Vec3f(0.0f, 1.0f, 0.0f ), float(PI_QUARTER)) );
  Transform * pRoot = beginEdit( Transform::create() );
  pRoot->setTrafo( rootTrafo );

  // positioning the shapes
  Trafo shapeTrafo;
  shapeTrafo.setOrientation( Quatf(Vec3f(1.0f, 0.0f, 0.0f ), float(PI_QUARTER)) );
  Transform * pShapeTrafo = beginEdit( Transform::create() );
  pShapeTrafo->setTrafo( shapeTrafo );

  Trafo shapeTrafo2;
  shapeTrafo2.setOrientation( Quatf(Vec3f(0.0f, 1.0f, 0.0f ), float(PI_QUARTER)) );
  Transform * pShapeTrafo2 = beginEdit( Transform::create() );
  pShapeTrafo2->setTrafo( shapeTrafo2 );

  Trafo shape2Trafo;
  shape2Trafo.setOrientation( Quatf(Vec3f(1.0f, 0.0f, 0.0f ), 0.0f) );
  shape2Trafo.setTranslation( Vec3f( -1.0f, 0.0f, 0.0f ) );
  Transform * pShape2Trafo = beginEdit( Transform::create() );
  pShape2Trafo->setTrafo( shape2Trafo );

  Trafo shape2Trafo2;
  shape2Trafo2.setOrientation( Quatf(Vec3f(0.0f, 1.0f, 0.0f ), float(PI_QUARTER)) );
  Transform * pShape2Trafo2 = beginEdit( Transform::create() );
  pShape2Trafo2->setTrafo( shape2Trafo2 );

  Trafo shape3Trafo;
  shape3Trafo.setOrientation( Quatf(Vec3f(1.0f, 0.0f, 0.0f ), 0.0f) );
  shape3Trafo.setTranslation( Vec3f( 1.0f, 0.0f, 0.0f ) );
  Transform * pShape3Trafo = beginEdit( Transform::create() );
  pShape3Trafo->setTrafo( shape3Trafo );

  // 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
  VertexAttributeSet * pVAS = beginEdit( VertexAttributeSet::create() );
  pVAS->setVertices( v, 36 );
  pVAS->setNormals( n, 36 );

  // Create a PrimitiveSet, in this case triangles.
  Triangles * pShape = beginEdit( Triangles::create() );
  pShape->setVertexAttributeSet( endEdit( pVAS ) );
  pShape->setFaces(f, 12);

  // Create a material.
  Material * pMaterial = beginEdit( Material::create() );
  pMaterial->setAmbientColor( Vec3f(0.f, 0.f, 1.f) );
  pMaterial->setDiffuseColor( Vec3f(0.4f, 0.4f, 0.4f) );
  pMaterial->setEmissiveColor( Vec3f(0.f, 0.f, 0.f) );
  pMaterial->setSpecularColor( Vec3f(1.f, 1.f, 1.f) );
  pMaterial->setSpecularExponent( 10.f );
  pMaterial->setOpacity( 1.0f );

  // Create a face attribute. The face attribute is a state attribute
  // that determines how the following faces will be rendered.
  const FaceAttribute * pFaceAttribute = FaceAttribute::create();

  // Create state set. Add material and render mode.
  StateSet * pStateSet = beginEdit( StateSet::create() );
  pStateSet->addAttribute( endEdit( pMaterial ) );
  pStateSet->addAttribute( pFaceAttribute );

  // Setup the whole scene graph
  GeoNode * pGeoNode = beginEdit( GeoNode::create() );
  pGeoNode->addGeometry( endEdit( pShape ), endEdit( pStateSet ) );

  const GeoNode * pGeoNode2 = pGeoNode->clone();

  // Note:
  // AddChild() will increment the reference count
  // of the added node.
  pShapeTrafo2->addChild( endEdit( pGeoNode ) );
  pShapeTrafo->addChild( endEdit( pShapeTrafo2 ) );
  pShape2Trafo2->addChild( pGeoNode2 );
  pShape2Trafo->addChild( endEdit( pShape2Trafo2 ) );
  pShape3Trafo->addChild( pGeoNode2 );
  pRoot->addChild( endEdit( pShapeTrafo ) );
  pRoot->addChild( endEdit( pShape2Trafo ) );
  pRoot->addChild( endEdit( pShape3Trafo ) );

  return( endEdit( pRoot ) );
}

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".

enum {WIDTH=128, HEIGHT=128, DEPTH=128, BPP=4};
unsigned char rgbas[WIDTH*HEIGHT*DEPTH*BPP];
[...] // init the rgbas buffer

const TextureImage * texStream = TextureImage::create(TextureImage::F_IMAGE_STREAM);
TextureImage * ncTexStream = beginEdit(texStream);
ncTexStream->createImage( WIDTH
                        , HEIGHT
                        , DEPTH
                        , BPP
                        , TextureImage::IMG_RGBA
                        , TextureImage::IMG_UNSIGNED_BYTE
                        , &rgbas[0] );

const TextureAttributeItem * texItem = TextureAttributeItem::create();
TextureAttributeItem * ncTexItem = beginEdit(texItem);
nvTexItem->setTextureImageSpec(string(), endEdit(ncTexStream));
ncTexItem->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);

ncTexItem->setTexGenLinearPlane(nvsg::TCA_S, nvsg::TGLP_OBJECT_AND_EYE, plane[0]);
ncTexItem->setTexGenLinearPlane(nvsg::TCA_T, nvsg::TGLP_OBJECT_AND_EYE, plane[1]);
ncTexItem->setTexGenLinearPlane(nvsg::TCA_R, nvsg::TGLP_OBJECT_AND_EYE, plane[2]);
ncTexItem->setTexGenMode(nvsg::TCA_S, nvsg::TGM_OBJECT_LINEAR);
ncTexItem->setTexGenMode(nvsg::TCA_T, nvsg::TGM_OBJECT_LINEAR);
ncTexItem->setTexGenMode(nvsg::TCA_R, nvsg::TGM_OBJECT_LINEAR);

// specify wrap modes
ncTexItem->setWrapMode(nvsg::TWCA_S, nvsg::TWM_REPEAT);
ncTexItem->setWrapMode(nvsg::TWCA_T, nvsg::TWM_REPEAT);
ncTexItem->setWrapMode(nvsg::TWCA_R, nvsg::TWM_REPEAT);

TextureAttribute * ncTexAttrib = beginEdit(TextureAttribute::create());
ncTexAttrib->bindTextureAttributeItem(endEdit(ncTexItem),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

TextureImage * ncTexStream = beginEdit(texStream);
  ncTexStream->demandUpload();
endEdit(ncTexStream);
renderArea->triggerRedraw();

[...]

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

  const CgFx * pCCgFx = CgFx::create();
  CgFxEffect * pEffect = beginEdit(pCCgFx->getEffect());
  string err;
  pEffect->createFromFile(cgfxFile, err);
  endEdit(pEffect);

  const StateSet * pCStateSet = StateSet::create();
  StateSet * pStateSet = beginEdit(pCStateSet);
  pStateSet->addAttribute(pCMaterial);
  if ( pCCgFx->getEffect()->isValid())
  {
    pStateSet->addAttribute(pCCgFx);
  }
  endEdit(pStateSet);

How do I set up a CgFX effect from lump?

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"
  );

  const CgFx * pCCgFx = CgFx::create();
  CgFxEffect * pEffect = beginEdit(pCCgFx->getEffect());
  string err;
  pEffect->createFromLump(srcCode, err);
  endEdit(pEffect);

  const StateSet * pCStateSet = StateSet::create();
  StateSet * pStateSet = beginEdit(pCStateSet);
  pStateSet->addAttribute(pCMaterial);
  if ( pCCgFx->getEffect()->isValid())
  {
    pStateSet->addAttribute(pCCgFx);
  }
  endEdit(pStateSet);

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 is the "normal" way to work with reference counted objects.
void modifySubtree(const nvsg::Node * node)
{
  const nvsg::Scene * scene = nvsg::Scene::create();
  scene->addRef();

  nvsg::Scene * editScene = beginEdit(scene);
    editScene->setRootNode(node);
  scene = endEdit(editScene);

  ModifyTraverser * traverser = new ModifyTraverser;
  traverser->addRef();
  traverser->apply(scene);

  traverser->removeRef();
  scene->removeRef();
}

The code above can lead to severe problems if you forget to decrement the reference count of your local object. 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.

This code uses nvutil::RCObject_AutoPtr and is the exact replacement of the code above:

void modifySubtree(const nvsg::Node * node)
{
  nvutil::RCObject_AutoPtr<const Scene> scene(nvsg::Scene::create());

  nvsg::Scene * editScene = beginEdit(scene.get());
    editScene->setRootNode(node);
  endEdit(editScene);

  nvutil::RCObject_AutoPtr<ModifyTraverser> traverser(new ModifyTraverser);
  traverser->apply(scene);
}

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->getViewporiteight());
   int raWidth  = int(m_pRA->getViewportWidth());

   const Camera * camera = m_pRA->getViewState()->getCamera();
   camera->getPickRay( mousePosX
                     , raHeight-mousePosY
                     , raWidth
                     , raHeight
                     , rayOrigin
                     , rayDirection);

   nvutil::RCObject_AutoPtr<StateSetApplyTraverser> rit(new RayIntersectTraverser);
   rit->setViewState(m_pRA->getViewState());
   rit->setRay( rayOrigin, rayDirection );
   rit->apply(GetDocument()->getScene());

   // determine the nearest object
   const nvsg::PrimitiveSet * pHitObject = NULL;

   if (rit->getNumberOfIntersections() > 0)
   {
       nvtraverser::Intersection intersection = rit->getNearest();
       nvutil::RCObject_AutoPtr<Drawable> 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
PrimitiveSet * primitiveSet = dynamic_cast<const PrimitiveSet*>(drawable);
if (primitiveSet)
{
  PrimitiveSet * ncPrimitiveSet = beginEdit(primitiveSet);

  if(ncPrimitiveSet->getHighlightObject() != NULL)
  {
    // allready highlighted, so remove highlight
    ncPrimitiveSet->attachHighlightObject(NULL);
  }
  else
  {
    // do bounding box highlighting
    ncPrimitiveSet->attachHighlightObject(HighlightBox::create());
  }
  endEdit(ncPrimitiveSet);

  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();
  [...]
}
\edcode

\code

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 offsToReleatedData;
};

void handleMyNode(const MyNode* p)
{
  if ( calculatingStorageRequirements() )
  {
    pseudoAlloc(sizeof(NBFMyNode));
    pseudeAlloc(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.

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.
...
const GeoNode * wheel(GeoNode::create()); // a GeoNode representing a car wheel
// ... setup wheel - not shown here

Transform * major(beginEdit(Transform::Create())); // for positioning the whole car
Transform * frontLeft(beginEdit(Transform::Create())); // for positioning the wheel to the front left
Transform * frontRight(beginEdit(Transform::Create())); // for positioning the wheel to the front right
Transform * backLeft(beginEdit(Transform::Create()));  // for positioning the wheel to the back left
Transform * backRight(beginEdit(Transform::Create())); // for positioning the wheel to the back right
// ... setup the transforms - not shown here

// put it all together
frontLeft->addChild(wheel);
frontRight->addChild(wheel);
backLeft->addChild(wheel);
backRight->addChild(wheel);

major->addChild(endEdit(frontLeft));
major->addChild(endEdit(frontRight));
major->addChild(endEdit(backLeft));
major->addChild(endEdit(backRight));
endEdit(major);

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.
Generated on Fri Aug 4 08:37:10 2006 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 Fri Aug 4 08:37:10 2006 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 Fri Aug 4 08:37:10 2006 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. 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/GeoNode.h" // base class definition

class MyGeoNode : public nvsg::GeoNode
{
public:
  MyGeoNode();
  //...
};

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 Node Components) 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 Fri Aug 4 08:37:10 2006 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 customing or inventing 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 read-only traversers and read-write traversers.

The uppermost abstract base class is Traverser . A parameter to it's constructor controls whether it's a read-only traverser or a read-write traverser. Some derived traversers like the RenderTraverser use it as a read-only traverser. Others like the AppTraverser use it as a read-write traverser. Traverser provides iterating functionality as well as per-object locking functionality, described as follows:

Iterating Functionality

The Traverser covers base iteration over a constant NVSG. Derived traversers can 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.

Per-Object Locking Functionality

Per-object locking allows for multiple read-only traversers to run in parallel in a multithreaded environment. Unlike the base iterating functionality, per-object locking is available for known NVSG objects as well as new NVSG objects invented by a third party developer.

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. The new traverser should inherit from an already existing Traverser that matches most of the requirements. If none exist, derive directly from Traverser and, depending on whether the new traverser should perform read-only or read-write operations on an NVSG, it's constructor should call the constructor of Traverser with the appropriate flag.

// Example of a custom read-only traverser

#include "nvtraverser/Traverser.h"

class MyTraverser : public Traverser
{
  public:
    MyTraverser() : Traverser( true ) {}    // use Traverser in read-only mode
  // ...
};

To add a new operation for a certain NVSG object, the developer needs to overload the matching handler routine for that object.

// MyTraverser.h
// Example for adding a custom operation for a Group

#include "nvtraverser/Traverser.h" // base class definition

// forward declare class Group to satisfy includees
namespace nvsg
{
  class Group;
}

class MyTraverser : public nvtraverser::Traverser
{
  // ...
protected:
  // handleGroup override
  NVSG_API virtual void handleGroup(const nvsg::Group * p);
};

The base classes provide a handler routine for each known and concrete NVSG object. The base implementations of these handler routines 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 routines.

// MyTraverser.cpp implementation file
#include "MyTraverser.h"
#include "nvsg/Group.h" // definition of Group

using namespace nvtraverser;
using namespace nvsg;

void MyTraverser::handleGroup(const Group * p)
{
  // ... add custom functionality

  // iterate subsequent objects by calling the base implementation
  Traverser::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 routine for the new object, and add it to the base class' handler routine table by means of the base class' member function addObjectHandler .

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
{
  // ...
};

// MyTraverser.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 MyTraverser : public nvtraverser::Traverser
{
  // ...
  protected:
    // constructor to deal with initial work
    MyTraverser();
    // clean up
    virtual ~MyTraverser();

    // 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);
};

// - - - - - - - - - - - - - - - - - - - - - - - -
// MyTraverser.cpp file
#include "MyTraverser.h"
#include "NewObject.h" // NewObject definition

MyTraverser::MyTraverser()
{
  // ...
  // add the new handler routine 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
  , &MyTraverser::handleNewGroup // handler routine
  );
  // ...
}

A handler routine 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 routine must take care of 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.

// MyTraverser.cpp

// ...

void MyTraverser::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 routine 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 routine for the particular child node.

// MyTraverser.cpp

// bad implementation:
void MyTraverser::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 while being traversed!
                                     // dangerous in multithreaded environments!
      break;
    case ... // handle other typed children
    ...
    }
  }
}

// good implementation:
void MyTraverser::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 routine
                                    // (2) the child node is locked while beeing traversed
  }
}

Back to Advanced

Generated on Fri Aug 4 08:37:10 2006 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

  • Memory Management
  • Important Concepts - Must Read for All Developers
Generated on Fri Aug 4 08:37:10 2006 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 Fri Aug 4 08:37:10 2006 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

1.-5. Change Render Mode

Click to switch between different render modes:

1. Point - Render the vertices of the model only.
2. Wire - Render in wire frame mode.
3. Shaded - Render using simple shader support.
4. Textured - Render using texture support.
5. Shader support - Render using full shader support, including vertex and fragment shaders.

6. Material Editor

Click to open the material editor, which lets you change the material color, textures, and shaders.

  • 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.

7. Geometry Smoothing

Click to smooth the edges in a geometry. You can define a crease angle (the angle between the face normals) at which the edge will be smoothed.

8.-11. Optimize Traverser (Unify)

8. State Set Unify 9. Transform Unify 10. GeoNode Unify 11. Drawable Unify

12. Optimize Geometry (Vertex Unify)

Click to unify vertices (or optimize) a scene by collapsing vertices of the geometry. You can enter an epsilon value that defines the distance between vertices. Vertices with a distance less than or equal to this epsilon will be collapsed.

13. Identity to Group

Click to replace identity transformations with simple group nodes.

14. Triangulate Geometry

Click to create Triangles.

14. Triangulate Geometry

Click to arrange independent triangles into triangle strips. This should be done whenever possible. You can define the minimum strip length.

16. Caching

Click to choose between no caching, display list caching (DL), or vertex buffer object caching (VBO). VBO is the fastest on modern GPUs.

17. Full Scene Antialiasing (FSAA)

Click to enable software full-scene antialiasing (FSAA). You can choose between different FSAA stages and techniques. Experiment to see which technique is the fastest on your graphics card. In many cases "Accumulation Buffer" is the fastest.

18. Transparency

Click to choose between different types of transparency.

  • 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.
  • Order-independent transparency does not require ordered rendering.

19. Culling

Click to choose culling tecniques. Currently the sample viewer supports only simple frustum culling, but later versions will support other culling strategies.

20.-27. Stereo

The sterero buttons let you manipulate the Quad-buffered OpenGL stereo settings. You must first enable OpenGL stereo in the display settings of your graphics card.

20. Stereo on 21. Increase stereo offset 22. Stereo offset default 23. Decrease stereo offset 24. Zero offset minus 25. Zero offset default 26. Zero offset plus 27. Reverse eyes

28. View All

Click to zoom to the extents of the current model to see the complete scene.

29. Undo View All

Click to zoom to undo the last zoom all command.

30. 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.

31. Selection Mode

Click to switch the viewer to selection mode, which lets you select objects in the scene.

32. Viewing Mode

Click to switch the viewer to viewing mode, which lets you manipulate the camera/model using the camera manipulator.

See 41. Trackball Manipulator - Examiner Mode , 42. Walk Manipulator - Walk Mode , and 43. Flight Manipulator - Flight Mode .

33. Bounding Box Highlighting

Click to highlight the bounding box of the object that you select.

34. Wire frame Highlight

Click to highlight the wire frame of the object that you select.

35. Save Home Position

Click to save the current camera settings - such as position and zoom.

36. Set To Home Position

Click to set the camera to the saved home position.

37. Clipping Planes

Click to change and manipulate the camera clipping planes.

38. 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.

39. Play Animation

Click to start and stop an animation in a scene.

40. Convert Animation

Click to convert a framed animation to a linear interpolated animation.

41. Trackball Manipulator - Examiner Mode

Click to set the trackball camera manipulator, which is active when the viewer is set to viewing mode (See 32. 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

42. Walk Manipulator - Walk Mode

Click to set the walk camera manipulator, which is active when the viewer is set to viewing mode (See 32. 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.

43. Flight Manipulator - Flight Mode

Click to set the fly camera manipulator, which is active when the viewer is set to viewing mode (See 32. 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.

44. 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 Fri Aug 4 08:37:10 2006 for NVSGSDK by NVIDIA


Legal Notice

Copyright (c) 2005 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 Fri Aug 4 08:37:10 2006 for NVSGSDK by NVIDIA


Memory Management

For NVSG, efficient memory management is key to optimizing performance and effectively utilizing available memory.

Introduction

Frequent memory allocations and deallocations play a significant role in degrading application performance. Because a default memory manager is general purpose, it cannot provide the best performance. Also, chaotic software systems tend to suffer from memory leaks and premature object deletion. Memory leaks eventually slow down an application, and premature object deletion can crash a system in cases where memory is accessed after it was already deleted.

NVSG uses a memory manager that is highly optimized for dealing with NVSG specific data structures, and addresses problems that are common to standard memory managers and more chaotic software systems. For example, NVSG uses reference counting, which results in a less chaotic software system that avoids memory corruption in terms of either memory leaks or premature deletion. (See also How to Enable Memory Leak Detection in Debug Mode.)

This section explains the memory management process used by NVSG, and how it affects the methods used to create and delete NVSG objects.

Principles of NVSG Memory Management

The IAllocator class provides an interface to the memory manager by overloading the new and delete operators. NVSG classes utilize this interface through inheritance. This design provides a standard way of using new and delete to allocate and deallocate objects from memory.

The other essential design for NVSG memory management is reference counting. Reference counting conveniently eliminates the burden of object ownership and is basically a simple form of garbage collection. NVSG objects inherit from RCObject, which provides the base functionality for reference counting - that is, encapsulation of the reference count methods and manipulations.

The NVSG framework uses reference counting to

  • Clarify ownership of pointers to NVSG objects and prevent premature deletion of these objects.
  • Automatically maintain data sharing between objects of the same type.

Proper Handling of NVSG Objects

The life of an NVSG object is as follows:

  1. A process creates/allocates the object. The reference counter initializes to zero.
  2. One or more process references the object. Each time a process references the object, the reference counter increments.
  3. When a process is finished using the object, it removes its reference to the object. Each time a process "unreferences" the object, the reference counter decrements.
  4. When the reference counter reaches zero, the object is deallocated.

To meet the requirements of a reference counting pattern, the creation, deletion, copying, and assignment of reference counted objects must be properly controlled.

Summary of Restrictions

NVSG objects are subject to certain restrictions with respect to memory management:

  • NVSG objects can live on heap only! The C++ compiler will reject any attempts to create an NVSG object on stack (automatic variable).
  • NVSG objects can be created by class specific static creation functions only. The C++ compiler will reject any attempts to create an NVSG object using the new operator.
  • Explicit deletion of NVSG objects is not permitted! The C++ compiler will also reject attempts to explicitly delete NVSG objects.

GeoNode node;                               // error! NVSG objects can live on heap only!
GeoNode *pNode0 = new GeoNode;              // error! NVSG objects can't be created using \c new
const GeoNode * pNode1= GeoNode::create();  // fine, creating a GeoNode object on heap using the creation function
// ...
delete pNode1;                              // error! explicit deletion of NVSG objects is not permitted

As a consequence, one cannot store NVSG objects in STL containers like vector or map. Of course, pointers to NVSG objects can be stored in STL containers.

Creating Objects

After creating an NVSG object, the reference count of that object is 0. In other words, the object has been allocated and constructed but not yet referenced. To properly reference the object, one must call addRef on that object.

const GeoNode * pNode = GeoNode::create();  // allocate and construct a GeoNode object
                                            // reference count is 0!
pNode->addRef(); // reference the newly created object
                 // reference count is 1!

The reason that the reference count of an NVSG object is 0 after allocation and construction is that, in many cases, code that allocates and constructs the object does not really reference it, but instead passes it to subsequent layers. In that situation, it would result in unnecessary overhead to also manage the object's life time. For example, a loader might construct a GeoNode object and pass it to a Transform object. In this case the Transform code would be the code which actually references the GeoNode object.

const Transform * pTrafo = Transform::create();
pTrafo->addRef();
const GeoNode * pNode = GeoNode::create();  // create a GeoNode object
Transform * pNC = beginEdit( pTrafo );
pNC->addChild(pNode);                       // pass the GeoNode object to the Transform
endEdit( pNC );
// ... no need to care about the GeoNode's lifetime

Destroying Objects

A NVSG object is destroyed and deallocated from memory after its reference count reaches 0 - that is, when nobody is using it any longer. For proper tracking of an object's ownership, code that no longer references an object should call removeRef on that object.

const GeoNode * pNode = GeoNode::create();  // allocate and construct a GeoNode object
                                            // reference count is 0!
pNode->addRef(); // reference the newly created object
                 // reference count is 1!
pNode->removeRef(); // unreference the object
                    // reference count reaches 0,
                    // and hence the object is destroyed and deallocated from memory

Back to Fundamental Concepts

Generated on Fri Aug 4 08:37:10 2006 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:

const TextureAttribute * texAttrib = TextureAttribute::create();
TextureAttribute * ncTexAttrib = beginEdit( texAttrib );
for (size_t i=0; i<numTextures; i++)
{
  const TextureAttributeItem * item = TextureAttributeItem::create();
  TextureAttributeItem * ncItem = beginEdit( item );
  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]);
  endEdit( ncItem );

  // bind the item
  ncTexAttrib->bindTextureAttributeItem(item, i); // put the texture into texture unit i

  // texture environment mode
  ncTexAttrib->setEnvMode(TEM_BLEND);
}
endEdit( ncTexAttrib );

Back to Advanced

Generated on Fri Aug 4 08:37:10 2006 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.

NVSG Core Classes
The NVSG core classes form the building blocks to create a directed acyclic graph (DAG).

NVSG 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.

Memory Management
This section discusses how NVSG objects are allocated and deallocated in memory.

Back to Fundamental Concepts

Generated on Fri Aug 4 08:37:10 2006 for NVSGSDK by NVIDIA


NVSG Core Classes

The namespace nvsg contains all classes that form the building blocks to create a directed acyclic graph (DAG). In the following, we refer to these classes as the NVSG core classes. Together, all NVSG core classes build a class hierarchy with Object as the common base class. All NVSG core classes are reference counted and utilize a highly optimized Memory Management.

In general, we distinguish between three kinds of objects:

  • Nodes
  • Node Components
  • Superior Objects (not part of the graph)

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.

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. Material , or Triangles are examples of node components.

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.

See also:
Overview of the Principal Classes
Back to Fundamental Concepts
Generated on Fri Aug 4 08:37:10 2006 for NVSGSDK by NVIDIA


NVSG Objects

The term 'NVSG objects' covers all class objects that inherit from nvsg::Object. Through this relationship all NVSG objects behave the same way regarding general object management.
This page gives a brief introduction on how to use NVSG objects in general. It also gives a short description of the major concepts used for NVSG objects. It contains the following sections:

  • Optimized Memory Management for NVSG Objects
  • Object Level Reference Counting
  • Creating NVSG Objects
  • Using NVSG Objects
  • Modifying NVSG Objects
  • Sharing Data Between Kindred NVSG Objects
  • Deleting NVSG Objects

See also:
How to Derive an NVSG Object

Optimized Memory Management for NVSG Objects

All NVSG objects make use of a special allocator through the nvutil::IAllocator interface. This allocator is highly optimized for the needs of NVSG objects. NVSG objects can live on heap only. Any attempts to create an arbitrary NVSG object on stack will be rejected by the compiler. See Creating NVSG Objects for more details on creating NVSG objects. The reference counting and data sharing concepts require this limitation. See Object Level Reference Counting and Sharing Data Between Kindred NVSG Objects for more details on these topics.

Object Level Reference Counting

All NVSG objects - for example nvsg::Drawable, nvsg::Node, nvsg::StateAttribute, etc. - inherit from nvsg::Object. As nvsg::Object inherits from nvutil::RCObject, all NVSG objects are reference counted. This is particularly necessary if an object is referenced multiple times within a certain scene. For example, a car tire might be referenced four times for a car model.
The nvutil::RCObject class provides the necessary interface for proper reference counting on object level. See Using NVSG Objects for more details on how to use the nvutil::RCObject interface.

Creating NVSG Objects

NVSG objects can only be created by class-specific static creation functions. Any attempts to create a NVSG object on stack will be rejected by the compiler. Therefore, the only way to instantiate an NVSG object is to create it on heap:

  using namespace nvsg;
  // Instantiate a GeoNode
  const GeoNode * pGeoNode = GeoNode::create();

Note:
The reference count for NVSG objects is initially zero!

Using NVSG Objects

After creating and before using an NVSG object, the object's reference count should be incremented. This ensures the pointer to the object is valid until the object's reference count is decremented again:

  using namespace nvsg;
  // Instantiating a GeoNode
  const GeoNode * pGeoNode = GeoNode::create();
  pGeoNode->addRef();
  // ... use the GeoNode instance

  // ... and after usage
  pGeoNode->removeRef();

Modifying NVSG Objects

NVSG Objects are created as pointers to constants and can't be modified directly. Any modification to NVSG Objects must be encased by calls to beginEdit() and endEdit() to ensure save access in multithreaded environments:

const GeoNode * pGeoNode;               // a GeoNode after creation
GeoNode * pNC = beginEdit( pGeoNode );  // get a pointer to modify the GeoNode
//  ... modify the GeoNode instance

//  ... and after modifying
endEdit( pNC );

Note:
Before modifying an NVSG Object be sure that you have called addRef() on it somewhere.

Sharing Data Between Kindred NVSG Objects

Beneath the reference counting at the object level, NVSG objects are capable of sharing their data between kindred objects. Unlike reference counting at the object level, this capability is handled automatically.

An arbitrary NVSG object shares its data with a kindred object if

  • it was constructed from a kindred object by invoking the object's copy constructor, or
  • if a kindred object was assigned to that object.

  // Sharing data between GeoNodes
  using namespace nvsg
  // Instantiate a GeoNode
  const GeoNode * pGeoNode = GeoNode::create();
  // Instantiating a copy of the GeoNode, pGeoNode is pointing to
  const GeoNode * pAnotherGeoNode = GeoNode::create(*pGeoNode);
  // The objects pointed to by pGeoNode and pAnotherGeoNode, share the same data now
  // ...
  // Instantiate a third Geo node
  const GeoNode * pAThirdGeoNode = GeoNode::create();
  // re-assign it
  GeoNode * pNC = beginEdit( pAThirdGeoNode );
  *pNC = *pGeoNode;
  endEdit( pNC );
  // Now the object pointed to by pAThirdGeoNode shares its data with the objects pointed to
  // by pGeoNode and pAnotherGeoNode

Note:
If an object shares its data with other objects, it will automatically split off its own copy of that data once the object initiates a modifying access on that data.

Deleting NVSG Objects

It is prohibited by the compiler to explicitly call delete on a pointer to an arbitrary NVSG object. After a call to removeRef an NVSG object will be deleted automatically after its reference count reaches zero.
Remarks:
After creating an NVSG object, its initial reference count is zero. The reason for this is that, in most cases, client code instantiates and initializes an NVSG object but no longer directly uses the object's interface. Instead, it hands over the object to subsequent layers. In doing so, the client code does not need to care about the object's lifetime but the subsequent layer needs the following:
  using namespace nvsg;
  // instantiate a default Transform
  const Transform * pTrafo = Transform::create();
  // instantiating a GeoNode
  const GeoNode * pGeoNode = GeoNode::create();
  // ... initialize the GeoNode here
  // ...
  // hand over the GeoNode to the Transform as child
  Transform * pNC = beginEdit( pTrafo );
  pNC->addChild(pGeoNode);
  endEdit( pNC );
  // ... don't care about the GeoNode's lifetime, the Transform does
Note:
Because the reference count of a NVSG object initially is zero, it is an error to call removeRef on a pointer to a NVSG object without having called addRef on that pointer beforehand!
Back to Fundamental Concepts
Generated on Fri Aug 4 08:37:10 2006 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
  • Node Components
  • Superior Objects

Node Core Classes

Non-Concrete Node Classes

Non-concrete Node classes are all Node classes that will not be instantiated.

Node
LightSource

Concrete Node classes

GeoNode
Drawable
Stateset

Group
LOD
Switch
Transform
AnimatedTransform

DirectedLight
PointLight
SpotLight

Node Component Core Classes

Non-Concrete Node Component Classes

Animation
InterpolatedAnimation

HighlightObject

StateAttribute

Concrete Node Component Classes

FramedAnimation
LinearInterpolatedAnimation

Quads
AnimatedQuads
QuadStrips
Triangles
AnimatedTriangles
SkinnedTriangles
TriStrips

HighlightBox
HighlightEdges

StateSet

CgFx
FaceAttribute
Material
TextureAttribute
TextureAttributeItem

Superior Object Core Classes

Non-Concrete Superior Object Classes

Camera

Concrete Superior Object Classes

ParallelCamera
PerspectiveCamera

Scene
ViewState

See also:
NVSG Core Classes
Back to Fundamental Concepts
Generated on Fri Aug 4 08:37:10 2006 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.

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 Fri Aug 4 08:37:10 2006 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 Fri Aug 4 08:37:10 2006 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 Fri Aug 4 08:37:10 2006 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 Fri Aug 4 08:37:11 2006 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->getViewDirection();
  nvmath::Vec3f projectionPlaneNormal = camera->getViewDirection();

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 Fri Aug 4 08:37:11 2006 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 Fri Aug 4 08:37:11 2006 for NVSGSDK by NVIDIA


Working with Lights

Lights can be handled like any other geometry. Their position and/or orientation are determined by the nvsg::Transform node they are child of. There can be any number of lights in a scene, but some traversers might pay attention to only a limited number of them. The nvtraverser::GLTraverser, for example, handles just the first eight lights it encounters.

Currently there are three different types of light sources:

nvsg::DirectedLight A directed light has no position, only direction. It represents a distant light source with parallel rays, such as the sun for example.

nvsg::PointLight A point light has a position in space, but no direction. The light rays emanate from it's position in every direction, such as from a light bulb for example.

nvsg::SpotLight A spot light has both position and direction. The light rays emanate from the position in only a limiting cone around it's direction.

Back to Fundamental Concepts

Generated on Fri Aug 4 08:37:11 2006 for NVSGSDK by NVIDIA


Working With NVSG Classes

Information on how to work with NVSG classes is provided in the following sections:

Memory Management

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 Fri Aug 4 08:37:11 2006 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::Texture are ignored.
Back to Fundamental Concepts
Generated on Fri Aug 4 08:37:11 2006 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). 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 these DLLs is Microsoft Visual C++. For a description of how to create a new plug-in see Creating a New Plug-in Project.

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 )

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;
}

Back to Advanced

Generated on Fri Aug 4 08:37:11 2006 for NVSGSDK by NVIDIA


Graphical Class Hierarchy

NVSGSDK Graphical Class Hierarchy

Go to the textual class hierarchy

Generated on Fri Aug 4 08:40:36 2006 for NVSGSDK by NVIDIA


Assert.h Source File

Assert.h

00001 #pragma once
00002
00003 #include "nvsg/nvsgapi.h"  // storage-class defines
00004
00005 namespace nvutil
00006 {
00007   extern NVSG_API void AssertionFailed(const char* assertion, const char* file, unsigned int line, const char * function);
00008 } // namespace nvutil
00009
00010 #if !defined(NDEBUG) && !defined(NVSG_HYBRID)
00011 // assert macro
00012 #if defined(LINUX)
00013 #define NVSG_ASSERT(exp) \
00014   if (exp){ \
00015   } else { \
00016     nvutil::AssertionFailed(#exp, __FILE__, __LINE__, __func__); \
00017   }
00018 #else
00019 #include <assert.h>
00020 #define NVSG_ASSERT assert
00021 #endif
00022
00023 // verify the expression f succeeds
00024 #define NVSG_VERIFY(f) NVSG_ASSERT(f)
00025
00026
00028  #define NVSG_CTASSERT(exp) NVSG_CTASSERTi(exp,__NVSG_CTASSERT_PREFIX,__LINE__)
00029  #if ! defined( DOXYGEN_IGNORE )
00030  #define NVSG_CTASSERTi(exp,prefix,line) NVSG_CTASSERTii(exp,prefix,line)
00031 #define NVSG_CTASSERTii(exp,prefix,line) static int prefix##__ctassert__##line[(exp)!=0] = {0}
00032  #endif
00033
00034 #else // non-debug configuration
00035
00036 #define NVSG_ASSERT(exp) static_cast<void>(0)
00037 #define NVSG_VERIFY(f)  (static_cast<void>(f))
00038 #define NVSG_CTASSERT(exp)
00039 #define NVSG_CTASSERTi(exp,cnt)
00040 #define NVSG_CTASSERTii(exp,cnt)
00041 #endif
00042
Generated on Fri Aug 4 08:32:59 2006 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
H
NBFFramedTrafoAnimation Plane3f (nvmath) StateSet (nvsg)
addReference (nvutil) HighlightBox (nvsg) NBFFramedVNVectorAnimation plane_t StateSetUnifyTraverser (nvtraverser)
Allocator (nvutil) HighlightEdges (nvsg) NBFGeoNode PlugIn (nvutil) StateVariant (nvsg)
AnalyzeResult (nvtraverser) HighlightObject (nvsg) NBFGroup PlugInCallback (nvutil) str_t
AnalyzeTraverser (nvtraverser)
I
NBFHeader PlugInCallback::EmptyTokenInfo (nvutil) StrippedPrimitiveSet (nvsg)
AnimatedQuads (nvsg) IAllocator (nvutil) NBFIndependentPrimitiveSet PlugInCallback::FileAccessFailedInfo (nvutil) StrippingTraverser (nvtraverser)
AnimatedTransform (nvsg) IdentityResult (nvtraverser) NBFInterpolatedAnimation PlugInCallback::FileMappingFailedInfo (nvutil) Switch (nvsg)
AnimatedTriangles (nvsg) IdentityToGroupTraverser (nvtraverser) NBFInterpolatedTrafoAnimation PlugInCallback::IncompatibleFileInfo (nvutil) SwitchToGroupTraverser (nvtraverser)
Animation (nvsg) ILTexLoader NBFInterpolatedVNVectorAnimation PlugInCallback::IncompatibleValueInfo (nvutil)
T
AnimationManipulator (nvui) Incarnation (nvutil) NBFLightSource PlugInCallback::InvalidFileInfo (nvutil) texBinding_t
AppTraverser (nvtraverser) IndependentPrimitiveSet (nvsg) NBFLineAttribute PlugInCallback::InvalidValueInfo (nvutil) texCoordSet_t
B
indexSet_t NBFLoader PlugInCallback::UndefinedTokenInfo (nvutil) texImage_t
BellFilter (nvsg) InterpolatedAnimation (nvsg) NBFLOD PlugInCallback::UnexpectedTokenInfo (nvutil) TextureAttribute (nvsg)
Billboard (nvsg) Intersection (nvtraverser) NBFMaterial PlugInCallback::UnknownTokenInfo (nvutil) TextureAttributeItem (nvsg)
Bit (nvutil) ISWMRSync (nvutil) NBFMeshedPrimitiveSet PlugInCallback::UnsupportedTokenInfo (nvutil) TextureAttributeItemData (nvsg)
Bitmap (nvsg)
K
NBFNode PlugInServer (nvutil) TextureImage (nvsg)
BlendAttribute (nvsg) KeyInput (nvui) NBFObject PointAttribute (nvsg) TextureLoader (nvsg)
Bone (nvsg) keyVariant_t NBFParallelCamera PointerReference (nvutil) Trace (nvutil)
bone_t
L
NBFPerspectiveCamera PointLight (nvsg) traceConsoleDebugOutput (nvutil)
BoxFilter (nvsg) Lanczos3Filter (nvsg) NBFPointAttribute Points (nvsg) traceConsoleOutput (nvutil)
BSplineFilter (nvsg) LightSource (nvsg) NBFPointLight PrimitiveAttribute (nvsg) traceDebugOutput (nvutil)
C
LinearInterpolatedAnimation (nvsg) NBFPrimitiveSet PrimitiveSet (nvsg) traceFileConsoleOutput (nvutil)
Camera (nvsg) LineAttribute (nvsg) NBFSaver PrimitiveSetCombineTraverser (nvtraverser) traceFileDebugOutput (nvutil)
CgFx (nvsg) Lines (nvsg) NBFSaveTraverser PrimitiveSetUnifyTraverser (nvtraverser) traceFileOutput (nvutil)
CgFxEffect (nvsg) LineStrips (nvsg) NBFScene ProblemInfo (nvutil) TraceFunctor (nvutil)
Chunk (nvutil) Lockable (nvutil) NBFSkinnedTriangles
Q
Trackball (nvutil)
CullData (nvsg) LOD (nvsg) NBFSpotLight QuadMeshes (nvsg) TrackballCameraManipulator (nvui)
CullTraverser (nvtraverser) LODCombineTraverser (nvtraverser) NBFStateAttribute Quads (nvsg) TrackballTransformManipulator (nvui)
D
LODEliminateTraverser (nvtraverser) NBFStatePass QuadStrips (nvsg) Trafo (nvmath)
DALData (nvsg) Log (nvutil) NBFStateSet Quatf (nvmath) trafo_t
DALDataCreator (nvsg)
M
NBFStateVariant
R
Transform (nvsg)
DALHost (nvsg) Manipulator (nvui) NBFStrippedPrimitiveSet RayIntersectTraverser (nvtraverser) TransformCombineTraverser (nvtraverser)
DenormalizedNormalsResult (nvtraverser) Map (nvsg) NBFSwitch RCIPtr (nvutil) TransformManipulator (nvui)
DepthAttribute (nvsg) MapArray (nvsg) NBFTextureAttribute RCObject (nvutil) TransformStack (nvutil)
DestrippingTraverser (nvtraverser) MapElement (nvsg) NBFTextureAttributeItem RCObject_AutoPtr (nvutil) Traverser (nvtraverser)
DirectedLight (nvsg) MapList (nvsg) NBFTrafoAnimation RCPtr (nvutil) TriangleFilter (nvsg)
Drawable (nvsg) MapMatrix (nvsg) NBFTransform RCVector (nvutil) Triangles (nvsg)
E
MapObject (nvsg) NBFVertexAttributeSet RegVal (nvutil) TriangulateTraverser (nvtraverser)
EmptyResult (nvtraverser) Mat33f (nvmath) NBFViewState removeReference (nvutil) TriFans (nvsg)
EquivalenceResult (nvtraverser) Mat44f (nvmath) NBFVNVectorAnimation RenderArea (nvui) TriStrips (nvsg)
F
Material (nvsg) Node (nvsg) RenderTraverser (nvtraverser) tweak_t
Face (nvsg) Matnnf (nvmath) NormalizeTraverser (nvtraverser)
S
U
FaceAttribute (nvsg) MemFunTbl (nvutil) NullNormalsResult (nvtraverser) sampler_t UPIID (nvutil)
FixedAllocator (nvutil) MeshedPrimitiveSet (nvsg) NVBLoader ScaleFilter (nvsg) UPITID (nvutil)
FlightCameraManipulator (nvui) meshSet_t NVBLoadTraverser Scene (nvsg)
V
FramedAnimation (nvsg) MissingResult (nvtraverser) NVNVB SceneLoader (nvsg) VariantIterator (nvsg)
FrustumCullTraverser (nvtraverser) ModelViewTraverser (nvtraverser) NVSGException (nvsg) SceneSaver (nvsg) Vec2f (nvmath)
G
MouseInput (nvui) NVSGLight SearchTraverser (nvtraverser) Vec3f (nvmath)
geometrySet_t
N
NVSGLoader Shape (nvsg) Vec4f (nvmath)
GeoNode (nvsg) NBFAnimatedIndependents NVSGMaterial ShortStrippedResult (nvtraverser) Vecnf (nvmath)
GeoNodeCombineTraverser (nvtraverser) NBFAnimatedTransform NVSGSaver SingleChildResult (nvtraverser) VertexAttributeSet (nvsg)
GeoNodeUnifyTraverser (nvtraverser) NBFBillboard NVSGSaveTraverser Singleton (nvutil) VertexAttributeSetUnifyTraverser (nvtraverser)
GLContext (nvgl) NBFBlendAttribute
O
Skin (nvsg) VertexUnifyTraverser (nvtraverser)
GLFunctions (nvgl) NBFCamera Object (nvsg) skin_t ViewState (nvsg)
GLMFCRAWnd (nvui) NBFCgFx Offset_AutoPtr SkinnedTriangles (nvsg) VNVector (nvsg)
GLObjects (nvgl) NBFDepthAttribute OptimizeTraverser (nvtraverser) SmoothTraverser (nvtraverser)
W
GLTraverser (nvtraverser) NBFDirectedLight
P
Sphere3f (nvmath) WalkCameraManipulator (nvui)
GLWinRenderArea (nvui) NBFDrawable ParallelCamera (nvsg) SpotLight (nvsg) WRLLoader
Group (nvsg) NBFFaceAttribute Path (nvsg) StateAttribute (nvsg) WRLLoadTraverser
GroupEliminateTraverser (nvtraverser) NBFFramedAnimation PerspectiveCamera (nvsg) StatePass (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 Fri Aug 4 08:36:29 2006 for NVSGSDK by NVIDIA


GeoNodeCombineTraverser.h Source File

GeoNodeCombineTraverser.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 <list>
00015
00016 #include "nvsgcommon.h"
00017
00018 #include "nvtraverser/OptimizeTraverser.h"
00019
00020 namespace nvtraverser
00021 {
00023
00024   class GeoNodeCombineTraverser : public OptimizeTraverser
00025   {
00026     public:
00028       NVSG_API GeoNodeCombineTraverser( void );
00029
00030     protected:
00032       NVSG_API virtual ~GeoNodeCombineTraverser( void );
00033
00035       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p
00036                                                    );
00037
00039       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p
00040                                            );
00041
00043       NVSG_API virtual void handleGroup( const nvsg::Group * p
00044                                        );
00045
00047       NVSG_API virtual void handleTransform( const nvsg::Transform * p
00048                                            );
00049
00050     private:
00051       void combineGeoNodes( const nvsg::Group *p );
00052   };
00053
00054 }
Generated on Fri Aug 4 08:33:01 2006 for NVSGSDK by NVIDIA


GeoNodeUnifyTraverser.h Source File

GeoNodeUnifyTraverser.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 <list>
00015 #include "nvsgcommon.h"
00016 #include "nvtraverser/OptimizeTraverser.h"
00017
00018 namespace nvtraverser
00019 {
00021
00022   class GeoNodeUnifyTraverser : public OptimizeTraverser
00023   {
00024     public:
00026       NVSG_API GeoNodeUnifyTraverser( void );
00027
00028     protected:
00030       NVSG_API virtual ~GeoNodeUnifyTraverser( void );
00031
00033       NVSG_API virtual void doApply( const nvsg::Scene *pScene );
00034
00035       NVSG_API virtual void handleAnimatedTransform( const nvsg::AnimatedTransform *p );
00036       NVSG_API virtual void handleBillboard( const nvsg::Billboard * p );
00037       NVSG_API virtual void handleGroup( const nvsg::Group * p );
00038       NVSG_API virtual void handleLOD( const nvsg::LOD *p );
00039       NVSG_API virtual void handleSwitch( const nvsg::Switch * p );
00040       NVSG_API virtual void handleTransform( const nvsg::Transform * p );
00041
00042     private:
00043       void unifyGeoNodes( const nvsg::Group *p );
00044
00045     private:
00046       std::vector<const nvsg::GeoNode *> m_geoNodes;
00047   };
00048
00049 }
Generated on Fri Aug 4 08:33:01 2006 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
00017 namespace nvgl
00018 {
00019 #if !defined(DOXYGEN_IGNORE)
00020 // Overrides GL state callbacks.
00021 NVSG_API void GLCgGLRegisterStateCallbacks(CGcontext context);
00022 #endif
00023 }
Generated on Fri Aug 4 08:33:01 2006 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 * (GLAPI * PFNGLXQUERYEXTENSIONSSTRINGPROC) (Display *dpy, int screen );
00022
00023 typedef GLXContext   (GLAPI * PFNGLXCREATECONTEXT) (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
00024 typedef void         (GLAPI * PFNGLXDESTROYCONTEXT) (Display *dpy, GLXContext ctx);
00025 typedef GLXContext   (GLAPI * PFNGLXGETCURRENTCONTEXT) (void);
00026 typedef Bool         (GLAPI * PFNGLXMAKECONTEXTCURRENTPROC) (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
00027 typedef GLXDrawable  (GLAPI * PFNGLXGETCURRENTREADDRAWABLEPROC) (void);
00028
00029 typedef GLXPbuffer   (GLAPI * PFNGLXCREATEGLXPBUFFERSGIXPROC) (Display *dpy, GLXFBConfig config,
00030                                                                unsigned int width,
00031                                                                unsigned int height,
00032                                                                const int *attrib_list);
00033 typedef void         (GLAPI * PFNGLXDESTROYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbuffer pbuf);
00034 typedef void         (GLAPI * PFNGLXQUERYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbuffer pbuf,
00035                                                               int attribute, unsigned int *value);
Generated on Fri Aug 4 08:33:03 2006 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 Fri Aug 4 08:40:22 2006 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
00058
00061   const nvsg::TextureImage * load( const std::string& filename
00062     );
00063
00064 protected:
00066
00070   virtual ~ILTexLoader();
00071
00072   // to reduce the overhead due to the large number of supported extensions,
00073   // we only instantiate this class once
00074   static ILTexLoader* m_instance;
00075   static size_t m_refCount;
00076 };
00077
00078 inline void ILTexLoader::deleteThis()
00079 {
00080   if( (--m_refCount)==0 )
00081   {
00082     delete this;
00083   }
00084 }
Generated on Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:33:04 2006 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 Fri Aug 4 08:33:04 2006 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
00015 typedef unsigned int UINT;
Generated on Fri Aug 4 08:33:04 2006 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"
Generated on Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:33:09 2006 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 Fri Aug 4 08:33:05 2006 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
Generated on Fri Aug 4 08:33:05 2006 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/RCObject.h"  // RCObject_AutoPtr
00017
00018 #include <map>
00019 #include <vector>
00020 #include <string>
00021
00022 // storage-class defines
00023 #if defined(_WIN32)
00024 # ifdef NBFLOADER_EXPORTS
00025 #  define NBFLOADER_API __declspec(dllexport)
00026 # else
00027 #  define NBFLOADER_API __declspec(dllimport)
00028 # endif
00029 #else
00030 #  define NBFLOADER_API
00031 #endif
00032
00033 #if defined(LINUX)
00034 void lib_init() __attribute__ ((constructor));   // will be called before dlopen() returns
00035 #endif
00036
00037 // exports required for a scene loader plug-in
00038 #if defined(LINUX)
00039 extern "C"
00040 {
00041 #endif
00042 NBFLOADER_API bool getPlugInterface(const nvutil::UPIID& piid, nvutil::PlugIn *& pi);
00043 NBFLOADER_API bool queryPlugInterfaceType(const nvutil::UPITID& pitid, std::vector<nvutil::UPIID>& piids);
00044 #if defined(LINUX)
00045 }
00046 #endif
00047
00048 // forward declaration
00049 namespace nvsg
00050 {
00051   class AnimatedQuads;
00052   class AnimatedTransform;
00053   class AnimatedTriangles;
00054   class Billboard;
00055   class BlendAttribute;
00056   class Camera;
00057   class CgFx;
00058   class DirectedLight;
00059   class Drawable;
00060   class FaceAttribute;
00061   class GeoNode;
00062   class Group;
00063   class LightSource;
00064   class Lines;
00065   class LOD;
00066   class Material;
00067   class Node;
00068   class ParallelCamera;
00069   class PerspectiveCamera;
00070   class PointAttribute;
00071   class PointLight;
00072   class Points;
00073   class QuadMeshes;
00074   class Quads;
00075   class QuadStrips;
00076   class SkinnedTriangles;
00077   class SpotLight;
00078   class StateAttribute;
00079   class StateSet;
00080   class TextureAttribute;
00081   class TextureAttributeItem;
00082   class TextureImage;
00083   class Transform;
00084   class Triangles;
00085   class TriStrips;
00086   class Switch;
00087   class Scene;
00088   class ViewState;
00089   template<typename T> class FramedAnimation;
00090   template<typename T> class InterpolatedAnimation;
00091 }
00092
00093 struct NBFGroup_nbf_11;
00094 template<typename T> class Offset_AutoPtr;
00095
00096
00098 class NBFLoader : public nvsg::SceneLoader
00099 {
00100 public:
00101   NBFLoader();
00102
00104
00105   void deleteThis( void );
00106
00108
00112   const nvsg::Scene * load(
00113     const std::string& filename
00114   , const std::vector<std::string> &searchPaths
00115   , const nvsg::ViewState *& viewState
00117   );
00118
00119 protected:
00121   virtual  ~NBFLoader(void);
00122
00124
00135   virtual const nvsg::Object * loadCustomObject(
00136     uint_t objectCode
00137   , uint_t offset
00138   );
00139
00141
00143   ubyte_t * mapOffset(
00144     uint_t offset
00145   , size_t numBytes
00146   );
00147
00149
00150   void unmapOffset(
00151     ubyte_t * offsetPtr
00152   );
00153
00154 private:
00155
00156   // handles automatic mapping and unmapping of file offsets
00157   template<typename T>
00158   friend class Offset_AutoPtr;
00159
00160   bool mapViewOfFile(const std::string& file);
00161   void unmapViewOfFile();
00162
00163   // assign an object to an offset
00164   void mapObject(uint_t offset, const nvsg::Object * object);
00165
00166   // animations
00167   const nvsg::Animation<nvmath::Trafo> * loadTrafoAnimation(uint_t offset);
00168   const nvsg::Animation<nvsg::VNVector> * loadVNVectorAnimation(uint_t offset);
00169   // ... framed
00170   const nvsg::FramedAnimation<nvmath::Trafo> * loadFramedTrafoAnimation(uint_t offset);
00171   const nvsg::FramedAnimation<nvmath::Trafo> * loadFramedTrafoAnimation_nbf_f(uint_t offset);
00172   const nvsg::FramedAnimation<nvsg::VNVector> * loadFramedVNVectorAnimation(uint_t offset);
00173   // ... interpolated
00174   const nvsg::InterpolatedAnimation<nvmath::Trafo> * loadInterpolatedTrafoAnimation(uint_t offset);
00175   const nvsg::InterpolatedAnimation<nvmath::Trafo> * loadInterpolatedTrafoAnimation_nbf_f(uint_t offset);
00176   const nvsg::InterpolatedAnimation<nvsg::VNVector> * loadInterpolatedVNVectorAnimation(uint_t offset);
00177   // cameras
00178   const nvsg::Camera * loadCamera(uint_t offset);
00179   const nvsg::ParallelCamera * loadParallelCamera(uint_t offset);
00180   const nvsg::PerspectiveCamera * loadPerspectiveCamera(uint_t offset);
00181   // drawables
00182   const nvsg::Drawable * loadDrawable(uint_t offset);
00183   const nvsg::SkinnedTriangles * loadSkinnedTriangles(uint_t offset);
00184   template<typename AnimatedType> const AnimatedType * loadAnimatedIndependents( uint_t offset );
00185   template<typename IndependentType> const IndependentType * loadIndependents( uint_t offset );
00186   template<typename MeshType> const MeshType * loadMeshes(uint_t offset);
00187   template<typename StripType> const StripType * loadStrips(uint_t offset);
00188   // scene
00189   const nvsg::Scene * loadScene(uint_t offset);
00190   const nvsg::Scene * loadScene_nbf_b(uint_t offset);
00191   // nodes
00192   const nvsg::Node * loadNode(uint_t offset);
00193   const nvsg::GeoNode * loadGeoNode(uint_t offset);
00194   const nvsg::Group * loadGroup(uint_t offset);
00195   const nvsg::Group * loadGroup_nbf_11(uint_t offset);
00196   const nvsg::Billboard * NBFLoader::loadBillboard(uint_t offset);
00197   const nvsg::Billboard * NBFLoader::loadBillboard_nbf_11(uint_t offset);
00198   const nvsg::Transform * loadTransform(uint_t offset);
00199   const nvsg::Transform * loadTransform_nbf_f(uint_t offset);
00200   const nvsg::Transform * loadTransform_nbf_11(uint_t offset);
00201   const nvsg::AnimatedTransform * loadAnimatedTransform(uint_t offset);
00202   const nvsg::AnimatedTransform * loadAnimatedTransform_nbf_f(uint_t offset);
00203   const nvsg::AnimatedTransform * loadAnimatedTransform_nbf_11(uint_t offset);
00204   const nvsg::LOD * loadLOD(uint_t offset);
00205   const nvsg::LOD * loadLOD_nbf_11(uint_t offset);
00206   const nvsg::Switch * loadSwitch(uint_t offset);
00207   const nvsg::Switch * loadSwitch_nbf_11(uint_t offset);
00208   const nvsg::LightSource * loadLightSource(uint_t offset);
00209   const nvsg::DirectedLight * loadDirectedLight(uint_t offset);
00210   const nvsg::PointLight * loadPointLight(uint_t offset);
00211   const nvsg::SpotLight * loadSpotLight(uint_t offset);
00212   // state attribs
00213   const nvsg::StateAttribute * loadStateAttribute(uint_t offset);
00214   const nvsg::BlendAttribute * loadBlendAttribute(uint_t offset);
00215   const nvsg::CgFx * loadCgFx(uint_t offset);
00216   const nvsg::DepthAttribute * loadDepthAttribute(uint_t offset);
00217   // ...
00218   const nvsg::FaceAttribute * loadFaceAttribute(uint_t offset);
00219   const nvsg::FaceAttribute * loadFaceAttribute_nbf_b(uint_t offset);
00220   const nvsg::LineAttribute * loadLineAttribute(uint_t offset);
00221   const nvsg::Material * loadMaterial(uint_t offset);
00222   const nvsg::Material * loadMaterial_nbf_a(uint_t offset);
00223   const nvsg::PointAttribute * loadPointAttribute(uint_t offset);
00224   const nvsg::TextureAttribute * loadTextureAttribute(uint_t offset);
00225   const nvsg::TextureAttributeItem * loadTextureAttributeItem(uint_t offset);
00226   const nvsg::TextureAttributeItem * loadTextureAttributeItem_nbf_12(uint_t offset);
00227   const nvsg::TextureAttributeItem * loadTextureAttributeItem_nbf_f(uint_t offset);
00228   const nvsg::TextureAttributeItem * loadTextureAttributeItem_nbf_e(uint_t offset);
00229
00230   const nvsg::TextureImage * loadTextureImage(uint_t offset, std::string& file);
00231
00232   // state set
00233   const nvsg::StateSet * loadStateSet(uint_t offset);
00234   const nvsg::StateSet * loadStateSet_nbf_10(uint_t offset);
00235   const nvsg::StateVariant * loadStateVariant(uint_t offset);
00236   const nvsg::StatePass * loadStatePass(uint_t offset);
00237   // view state
00238   const nvsg::ViewState * loadViewState(uint_t offset);
00239
00240   // vertex attribute set
00241   const nvsg::VertexAttributeSet * loadVertexAttributeSet( uint_t vasOffset, uint_t objectCode );
00242
00243   // shared object handling
00244   template <typename ObjectType, typename NBFObjectType>
00245   bool loadSharedObject(nvutil::RCObject_AutoPtr<ObjectType>& obj, Offset_AutoPtr<NBFObjectType>& objPtr);
00246
00247   // read in non-concrete objects
00248   void readObject(nvsg::Object * dst, const NBFObject * src);
00249   void readGroup(nvsg::Group * dst, const NBFGroup * src);
00250   void readGroup_nbf_11(nvsg::Group * dst, const NBFGroup_nbf_11 * src);
00251   void readPrimitiveSet(nvsg::PrimitiveSet * dst, const NBFPrimitiveSet * src);
00252   void readIndependentPrimitiveSet( nvsg::IndependentPrimitiveSet *dst, const NBFIndependentPrimitiveSet *src );
00253   void readLightSource(nvsg::LightSource * dst, const NBFLightSource * src);
00254   void readNode(nvsg::Node * dst, const NBFNode * src);
00255   void readCamera(nvsg::Camera * dst, const NBFCamera * src);
00256   void readTweak(nvsg::CgFxEffect * effect, const tweak_t * tweak);
00257   void readSampler(nvsg::CgFxEffect * effect, const sampler_t * sampler);
00258
00259   // map a string object (helper)
00260   std::string mapString(const str_t& str);
00261
00262 private:
00263
00264   enum
00265   {
00266     VIEWSIZE = 0x01000000 // limit to 16MB view size
00267   };
00268
00269   struct ViewHeader
00270   {
00271     ViewHeader()
00272       : basePtr(NULL)
00273       , startOffs(0)
00274       , endOffs(0)
00275       , refCnt(0)
00276     {}
00277     ubyte_t * basePtr;   // points to the beginning of the view
00278     size_t    startOffs; // the view's start offset inside the mapped file
00279     size_t    endOffs;   // the view's 'past tht end' offset inside the mapped file
00280     int refCnt; // reflects if the view is in use or not
00281   };
00282   std::vector<ViewHeader*>    m_mappedViews;  // collection of currently mapped views
00283   std::map<ubyte_t*, ViewHeader*> m_offsetPtrViewMap; // mapping offset pointers to their associated mapped view
00284 #if defined(_WIN32)
00285   HANDLE                m_file;         // file handle returned by CreateFile
00286   HANDLE                m_fileMapping;  // handle of file mapping object returned by CreateFileMapping
00287 #elif defined(LINUX)
00288   int                   m_file;         // file descriptor returned by open()
00289 #endif
00290   size_t                m_mappingSize;  // actual size of the file mapping
00291   size_t                m_allocationGranularity; // systems allocation granularity
00292   std::vector<std::string>        m_searchPaths;  // a private copy of the search pathes given to us via the load API
00293   std::map<uint_t, const nvsg::Object *> m_offsetObjectMap; // mapping offsets to NVSG objects
00294   std::map<nvsg::DataID, const nvsg::Object *> m_sharedObjectsMap; // lookup shared objects given the corresponding objectID
00295   // private copy of the nbf version used to save the file
00296   ubyte_t m_nbfMajor;   // major version
00297   ubyte_t m_nbfMinor;   // minor version
00298   ubyte_t m_nbfBugfix;  // bugfix level
00299
00300   // call some load routines via function pointers to preserve downward compatibility
00301   const nvsg::AnimatedTransform * (NBFLoader::*m_pfnLoadAnimatedTransform)(uint_t); // ... load AnimatedTransform
00302   const nvsg::Billboard     * (NBFLoader::*m_pfnLoadBillboard)(uint_t);     // ... load Billboard
00303   const nvsg::FaceAttribute * (NBFLoader::*m_pfnLoadFaceAttribute)(uint_t); // ... load FaceAttribute
00304   const nvsg::FramedAnimation<nvmath::Trafo> * (NBFLoader::*m_pfnLoadFramedTrafoAnimation)(uint_t); // ... load FramedAnimation<Trafo>
00305   const nvsg::Group * (NBFLoader::*m_pfnLoadGroup)(uint_t); // ... load Group
00306   const nvsg::InterpolatedAnimation<nvmath::Trafo> * (NBFLoader::*m_pfnLoadInterpolatedTrafoAnimation)(uint_t); // ... load InterpolatedAnimation<Trafo>
00307   const nvsg::LOD           * (NBFLoader::*m_pfnLoadLOD)(uint_t);           // ... load LOD
00308   const nvsg::Material      * (NBFLoader::*m_pfnLoadMaterial)(uint_t);      // ... load Material
00309   const nvsg::Scene         * (NBFLoader::*m_pfnLoadScene)(uint_t);         // ... load Scene
00310   const nvsg::Switch        * (NBFLoader::*m_pfnLoadSwitch)(uint_t);        // ... load Switch
00311   const nvsg::StateSet      * (NBFLoader::*m_pfnLoadStateSet)(uint_t);      // ... load StateSet
00312   const nvsg::TextureAttributeItem * (NBFLoader::*m_pfnLoadTextureAttributeItem)(uint_t); // ... load TextureAttributeItem
00313   const nvsg::Transform     * (NBFLoader::*m_pfnLoadTransform)(uint_t);     // ... load Transform
00314
00315   std::map<std::string,const nvsg::TextureImage*> m_textureImages;  // collection of currently loaded TextureImages
00316   std::map<std::string,const nvsg::CgFx*> m_cgfxEffects;
00317 };
00318
00319 inline void NBFLoader::deleteThis()
00320 {
00321   delete this;
00322 }
00323
00325
00327 template<typename T>
00328 class Offset_AutoPtr
00329 {
00330 public:
00332
00334   Offset_AutoPtr(NBFLoader * ldr, uint_t offset, size_t count=1)
00335     : m_ptr(NULL)
00336     , m_ldr(ldr)
00337   {
00338     if ( count )
00339     {
00340       m_ptr = (T*)m_ldr->mapOffset(offset, count*sizeof(T));
00341     }
00342   }
00343
00345   ~Offset_AutoPtr()
00346   {
00347     if ( m_ptr )
00348     {
00349       m_ldr->unmapOffset((ubyte_t*)m_ptr);
00350     }
00351   }
00352
00354   T* operator->() const { return m_ptr; }
00355
00357   T& operator*() const { return *m_ptr; }
00358
00360   operator const T*() const { return m_ptr; }
00361
00363
00365   void reset(uint_t offset, size_t count=1)
00366   {
00367     if ( m_ptr )
00368     {
00369       m_ldr->unmapOffset((ubyte_t*)m_ptr);
00370       m_ptr=NULL;
00371     }
00372     if ( count )
00373     {
00374       m_ptr = (T*)m_ldr->mapOffset(offset, count*sizeof(T));
00375     }
00376   }
00377
00378 private:
00379   T * m_ptr;
00380   NBFLoader * m_ldr;
00381 };
00382
00383
Generated on Fri Aug 4 08:33:05 2006 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  "nvsg/PlugInterface.h"
00015 #include  "nvtraverser/Traverser.h"
00016 #include  "nvsg/ViewState.h"
00017
00018 #include <map>
00019 #include <vector>
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
00044 class NBFSaveTraverser : public nvtraverser::Traverser
00045 {
00046   public:
00048     NBFSaveTraverser();
00049
00051     void preCalculateFileSize(const nvsg::Scene * scene);
00052
00053     // file mapping/unmapping
00054     enum
00055     {
00056       // proposed view granularity
00057       VIEWSIZE = 0x01000000 // 16 MB
00058     };
00059
00061     bool mapViewOfFile(const std::string& file);
00062
00064     void unmapViewOfFile();
00065
00067
00068     NBFSAVER_API virtual void setViewState( const nvsg::ViewState * viewState
00069                                           );
00070
00071   protected:
00072
00074
00081     bool calculatingStorageRequirements() const;
00082
00084
00093     uint_t alloc(
00094       void*& ptr
00095     , size_t numBytes
00096     );
00097
00099
00102     void dealloc(
00103       ubyte_t * offsetPtr
00104     );
00105
00107
00114     uint_t pseudoAlloc(
00115       size_t numBytes
00116     );
00117
00119     virtual void doApply( const nvsg::Scene * scene
00120     );
00121
00122     // overloads to process concrete types for saving
00123     // ...Cameras
00124     virtual void handleParallelCamera(const nvsg::ParallelCamera *p, const nvsg::Node *root);
00125     virtual void handlePerspectiveCamera(const nvsg::PerspectiveCamera *p, const nvsg::Node *root);
00126     // ...Nodes
00127     virtual void handleBillboard(const nvsg::Billboard *p);
00128     virtual void handleGeoNode(const nvsg::GeoNode *p);
00129     virtual void handleGroup(const nvsg::Group *p);
00130     virtual void handleTransform(const nvsg::Transform *p);
00131     virtual void handleAnimatedTransform(const nvsg::AnimatedTransform *p);
00132     virtual void handleLOD(const nvsg::LOD *p);
00133     virtual void handleSwitch(const nvsg::Switch *p);
00134     virtual void handleDirectedLight(const nvsg::DirectedLight *p);
00135     virtual void handlePointLight(const nvsg::PointLight *p);
00136     virtual void handleSpotLight(const nvsg::SpotLight *p);
00137     // ...StateSet
00138     virtual void handleStateSet(const nvsg::StateSet *p);
00139     virtual void handleStateVariant(const nvsg::StateVariant *p);
00140     virtual void handleStatePass(const nvsg::StatePass *p);
00141     // ...StateAttribs
00142     virtual void handleBlendAttribute(const nvsg::BlendAttribute *p);
00143     virtual void handleCgFx(const nvsg::CgFx *p);
00144     virtual void handleDepthAttribute(const nvsg::DepthAttribute *p);
00145     virtual void handleFaceAttribute(const nvsg::FaceAttribute *p);
00146     virtual void handleLineAttribute(const nvsg::LineAttribute *p);
00147     virtual void handleMaterial(const nvsg::Material *p);
00148     virtual void handlePointAttribute(const nvsg::PointAttribute *p);
00149     virtual void handleTextureAttribute(const nvsg::TextureAttribute *p);
00150     virtual void handleTextureAttributeItem(const nvsg::TextureAttributeItem * p, size_t tu);
00151     // ...GeoSets
00152     virtual void handleTriangles(const nvsg::Triangles *p);
00153     virtual void handleAnimatedTriangles(const nvsg::AnimatedTriangles *p);
00154     virtual void handleSkinnedTriangles(const nvsg::SkinnedTriangles *p);
00155     virtual void handleTriFans(const nvsg::TriFans *p);
00156     virtual void handleTriStrips(const nvsg::TriStrips *p);
00157     virtual void handleQuadMeshes(const nvsg::QuadMeshes *p);
00158     virtual void handleQuads(const nvsg::Quads *p);
00159     virtual void handleAnimatedQuads(const nvsg::AnimatedQuads *p);
00160     virtual void handleQuadStrips(const nvsg::QuadStrips *p);
00161     virtual void handleLines(const nvsg::Lines *p);
00162     virtual void handleLineStrips(const nvsg::LineStrips *p);
00163     virtual void handlePoints(const nvsg::Points *p);
00164     virtual void handleVertexAttributeSet( const nvsg::VertexAttributeSet *p );
00165     // ... Animations
00166     virtual void handleFramedTrafoAnimation(const nvsg::FramedAnimation<nvmath::Trafo> *p);
00167     virtual void handleFramedVNVectorAnimation(const nvsg::FramedAnimation<nvsg::VNVector> *p);
00168     virtual void handleLinearInterpolatedTrafoAnimation(const nvsg::LinearInterpolatedAnimation<nvmath::Trafo> *p);
00169     virtual void handleLinearInterpolatedVNVectorAnimation(const nvsg::LinearInterpolatedAnimation<nvsg::VNVector> *p);
00170
00171   private: // api covering implementation details
00172     struct Mapping
00173     {
00174       Mapping()
00175         : refCnt(0)
00176       {}
00177       ubyte_t * basePtr;
00178       size_t    size;    // needed with linux's unmap call only
00179       int       refCnt;  // reflects if the view is in use or not
00180     };
00181
00182     // operator() to process a Scene (not part of the public interface!)
00183     // returns the file offset to the allocated and initialized NBFScene object
00184     // behavior is undefined if p is an invalid pointer
00185     uint_t handleScene(const nvsg::Scene *p);
00186     // operator() to process a ViewState (not part of the public interface!)
00187     // returns the file offset to the allocated and initialized NBFViewState object
00188     // behavior is undefined if p is an invalid pointer
00189     uint_t handleViewState(const nvsg::ViewState *p);
00190
00191     // write routines for non-concrete types
00192     // ... write tasks similar for all Objects
00193     void writeObject(const nvsg::Object* nvsgObjPtr, NBFObject * nbfObjPtr, uint_t objCode);
00194     // ... write task similar for Nodes
00195     void writeNode(const nvsg::Node* nvsgNodePtr, NBFNode * nbfNodePtr, uint_t objCode);
00196     // ... write task similar for Groups
00197     void writeGroup(const nvsg::Group * nvsgGrpPtr, NBFGroup * nbfGrpPtr, uint_t objCode);
00198     // ... write task similar for LightSources
00199     void writeLightSource(const nvsg::LightSource* nvsgLightSrcPtr, NBFLightSource * nbfLightSrcPtr, uint_t objCode);
00200     // ... write task similar for Cameras
00201     void writeCamera(const nvsg::Camera * nvsgCamPtr, NBFCamera * nbfCamPtr, uint_t objCode);
00202     // ... write meshes
00203     template<typename MeshType>
00204       void writeMeshes(const MeshType * nvsgMeshesPtr, NBFMeshedPrimitiveSet * nbfMeshesPtr);
00205     // ... write strips
00206     template<typename StripType>
00207     void writeStrips(const StripType * nvsgStripsPtr, NBFStrippedPrimitiveSet * nbfStripsPtr);
00208     // .. write faces
00209     template<typename NVSGFaceType, typename NBFFaceType>
00210     void writeIndices(const NVSGFaceType * nvsgFaces, NBFFaceType * nbfFaces);
00211     void writePrimitive( const nvsg::PrimitiveSet * nvsgPrimitive, NBFPrimitiveSet * nbfPrimitive, uint_t objCode );
00212     // .. write StateSet data
00213     void writeStateSetBase( const nvsg::StateSet *p );
00214     void writeStateVariantBase( const nvsg::StateVariant *p );
00215     void writeStatePassBase( const nvsg::StatePass *p );
00216     // .. write a single tweakable
00217     void writeTweak(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter nvsgTweak, tweak_t * nbfTweak);
00218     // .. write a single sampler
00219     void writeSampler(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter nvsgSampler, sampler_t * nbfSampler);
00220     // .. write a single texture image
00221     void writeTexImage(const std::string& file, const nvsg::TextureImage * nvsgImg, texImage_t * nbfImg);
00222
00223     // shared objects processing
00224     bool processSharedObject(const nvsg::Object * obj, uint_t objCode);
00225
00226     // independents, meshes, and strips processing
00227     void processIndependentPrimitiveSet( const nvsg::IndependentPrimitiveSet *p, uint_t objCode );
00228     void processMeshedPrimitiveSet( const nvsg::MeshedPrimitiveSet *p, uint_t objCode );
00229     void processStrippedPrimitiveSet( const nvsg::StrippedPrimitiveSet *p, uint_t objCode );
00230
00231     // map an additional view of the file into our address space,
00232     // large enough to hold 'minimumNumberOfBytesToMap' bytes
00233     Mapping* remapViewOfFile(size_t minimumNumberOfBytesToMap);
00234
00235     // map cnt * sizeof(Type) bytes from the mapped file
00236     template <typename Type>
00237     uint_t alloc(Type *& objPtr, size_t cnt=1);
00238
00239     // pseudo allocation routines for calculation of storage requirements
00240     void pseudoAllocObject(const nvsg::Object* p);
00241     void pseudoAllocNode(const nvsg::Node* p);
00242     void pseudoAllocGroup(const nvsg::Group * p);
00243     void pseudoAllocLightSource(const nvsg::LightSource * p);
00244     void pseudoAllocPrimitive(const nvsg::PrimitiveSet * p);
00245     void pseudoAllocCamera(const nvsg::Camera * p);
00246     void pseudoAllocVertexAttributeSet(const nvsg::VertexAttributeSet *p);
00247     void pseudoAllocTweak(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter tweak);
00248     void pseudoAllocSampler(const nvsg::CgFxEffect * effect, nvsg::CgFxParameter sampler);
00249     void pseudoAllocTexImage(const std::string& file, const nvsg::TextureImage * img);
00250
00251     private:
00252     // handles automatic mapping and unmapping of file offsets
00253     template<typename T>
00254       friend class Offset_AutoPtr;
00255
00256     bool        m_calculateStorageRequirements; // pre-calculate what the file size would be
00257     size_t      m_preCalculatedFileSize; // required file size in bytes
00258 #if defined(_WIN32)
00259     HANDLE      m_file;       // file handle returned by CreateFile
00260     HANDLE      m_fileMapping; // handle of a file mapping object returned by CreateFileMapping
00261 #elif defined(LINUX)
00262     int         m_file;       // file descriptor returned by open()
00263 #endif
00264
00265     std::vector<Mapping*> m_mappedViews; // collection of currently mapped views
00266     std::map<ubyte_t*, Mapping*> m_offsetPtrViewMap; // mapping offset pointers to their associated mapped view
00267     size_t      m_viewSize;   // size in bytes of the file view that was mapped last
00268     size_t      m_allocationGranularity; // actual system's allocation granularity
00269     ubyte_t   * m_basePtr;    // points to the beginning of the current view of the file mapping
00270     ubyte_t   * m_filePtr;    // actual write position
00271     size_t      m_fileOffset; // actual file offset
00272     std::map<const nvsg::Object*, uint_t> m_objectOffsetMap; // mapping NVSG objects to the corresponding offsets in file mapping
00273     std::map<nvsg::DataID, uint_t> m_objectDataIDOffsetMap; // mapping object IDs of shared objects to corresponding offsets
00274 };
00275
00277 class NBFSaver : public nvsg::SceneSaver
00278 {
00279 public :
00281   NBFSaver();
00282
00284
00285   void deleteThis( void );
00286
00288
00289   bool save( const nvsg::Scene &scene
00290            , const nvsg::ViewState *viewState
00291            , const std::string& filename
00292            );
00293
00294 protected:
00295   virtual ~NBFSaver();
00296
00297 protected:
00298   NBFSaveTraverser * m_traverser;
00299 };
00300
00301
00302 inline void NBFSaver::deleteThis( void )
00303 {
00304   delete this;
00305 }
00306
00307
00309
00311 template<typename T>
00312 class Offset_AutoPtr
00313 {
00314 public:
00316
00318   Offset_AutoPtr(NBFSaveTraverser * svr, uint_t& fileOffset, size_t count=1)
00319     : m_ptr(NULL)
00320     , m_svr(svr)
00321   {
00322     NVSG_ASSERT(count != 0xCCCCCCCC);  // check for passing uninitialized variables
00323
00324     if ( count )
00325     {
00326       // call the void * version
00327       fileOffset = m_svr->alloc((void *&)m_ptr, count*sizeof(T));
00328     }
00329
00330   }
00331
00333
00335   Offset_AutoPtr(NBFSaveTraverser * svr)
00336     : m_ptr(NULL)
00337     , m_svr(svr)
00338   {
00339   }
00340
00342   ~Offset_AutoPtr()
00343   {
00344     if ( m_ptr )
00345     {
00346       m_svr->dealloc((ubyte_t*)m_ptr);
00347     }
00348   }
00349
00351   T* operator->() { NVSG_ASSERT(m_ptr); return m_ptr; }
00352
00354   T& operator*() { NVSG_ASSERT(m_ptr); return *m_ptr; }
00355
00357   operator T*() { NVSG_ASSERT(m_ptr); return m_ptr; }
00358
00360
00362   void alloc(uint_t& fileOffset, size_t count=1)
00363   {
00364     NVSG_ASSERT(m_ptr == NULL);
00365     NVSG_ASSERT(count != 0xCCCCCCCC);  // check for passing uninitialized variables
00366
00367     if ( count )
00368     {
00369       fileOffset = m_svr->alloc((void *&)m_ptr, count*sizeof(T));
00370     }
00371   }
00372
00373 private:
00374   T * m_ptr;
00375   NBFSaveTraverser * m_svr;
00376 };
00377
00378
00379
Generated on Fri Aug 4 08:33:06 2006 for NVSGSDK by NVIDIA


nv_attribute.h Source File

nv_attribute.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 #ifndef _nv_attribute_h_
00013 #define _nv_attribute_h_
00014
00015 #pragma warning (disable:4251)
00016
00017 #include <map>
00018 #include <string>
00019
00020 //  it's not neccessary to document this helper class !
00021 #if ! defined( DOXYGEN_IGNORE )
00022 class nv_attribute
00023 {
00024     typedef std::map<std::string,nv_attribute*> _dico;
00025     typedef _dico::value_type                   _dico_pair;
00026     typedef _dico::iterator                     _dico_it;
00027     typedef _dico::const_iterator               _dico_cit;
00028 public:
00029
00030     enum
00031     {
00032         NV_FLOAT                = 0x00000001,
00033         NV_CHAR                 = 0x00000002,
00034         NV_UNSIGNED_CHAR        = 0x00000004,
00035         NV_UNSIGNED_INT         = 0x00000008,
00036         NV_INT                  = 0x00000010,
00037         NV_SHORT                = 0x00000040,
00038
00039         NV_ARRAY                = 0x00010000,
00040         NV_FLOAT_ARRAY          = 0x00010001,
00041         NV_CHAR_ARRAY           = 0x00010002,
00042         NV_UNSIGNED_CHAR_ARRAY  = 0x00010004,
00043         NV_UNSIGNED_INT_ARRAY   = 0x00010008,
00044         NV_INT_ARRAY            = 0x00010010,
00045         NV_ATTRIBUTE_ARRAY      = 0x00010020,
00046         NV_SHORT_ARRAY          = 0x00010040,
00047         NV_STRING               = 0x00010002,
00048
00049         NV_UNASSIGNED           = 0xFFFFFFFF
00050     };
00051
00052     nv_attribute();
00053     nv_attribute(const nv_attribute & attr);
00054     ~nv_attribute();
00055
00056     // l-value assignation
00057     nv_attribute &          operator=           (const char * str);
00058     nv_attribute &          operator=           (const float & val);
00059     nv_attribute &          operator=           (const unsigned int & val);
00060     nv_attribute &          operator=           (const int & val);
00061     nv_attribute &          operator=           (const unsigned char & val);
00062     nv_attribute &          operator=           (const char & val);
00063     nv_attribute &          operator=           (const short & val);
00064     nv_attribute &          operator=           (const nv_attribute & attr);
00065
00066     // validation tests
00067     bool                    is_null             () const;
00068     bool                    is_valid            () const;
00069
00070     // accessor interface
00071     nv_attribute &          operator[]          (const char * name);
00072
00073     // array assignation
00074     void                    array               (const nv_attribute * attribs, unsigned int size);
00075     void                    array               (const float * fvector, unsigned int size);
00076     void                    array               (const char * str, unsigned int size);
00077     void                    array               (const unsigned char * str, unsigned int size);
00078     void                    array               (const unsigned int * array, unsigned int size);
00079     void                    array               (const int * array, unsigned int size);
00080     void                    array               (const short * array, unsigned int size);
00081
00082     // r-value accessors...
00083     float                   as_float            () const;
00084     unsigned int            as_unsigned_int     () const;
00085     unsigned int            as_int              () const;
00086     short                   as_word             () const;
00087     unsigned char           as_uchar            () const;
00088     char                    as_char             () const;
00089     const char *            as_char_array       () const;
00090     const unsigned char *   as_unsigned_char_array() const;
00091     const int *             as_int_array        () const;
00092     const unsigned int *    as_unsigned_int_array() const;
00093     const float *           as_float_array      () const;
00094     const short *           as_short_array      () const;
00095     const char *            as_string           () const;
00096     const nv_attribute *    as_attribute_array  () const;
00097
00098     // retrieve the size array of the array
00099     const unsigned int      get_size            () const;
00100
00101     // retrieve the type of the attribute
00102     const unsigned int      get_type            () const;
00103
00104     unsigned int            get_num_attributes  () const;
00105     const char *            get_attribute_name  (unsigned int i) const;
00106     const nv_attribute *    get_attribute       (unsigned int i) const;
00107
00108     friend std::ostream & operator << (std::ostream& os, const nv_attribute & attr);
00109
00110 protected:
00111     // delete the container and reset the value to zero
00112     void                    erase               ();
00113     void                    copy_from           (const nv_attribute * attr);
00114
00115 private:
00116     // dictionnary
00117     _dico                   _attr;
00118
00119     // 32 bit union for data storage
00120     union
00121     {
00122         void *              _pdata;
00123         unsigned char       _ubyte;
00124         unsigned char       _byte;
00125         short               _word;
00126         unsigned int        _udword;
00127         unsigned int        _sdword;
00128         float               _float;
00129     };
00130
00131     // to be only used for arrays only. The size is always in reference to the type.
00132     // example: if the type is float and size is 4, there is 3 floats in the array
00133     unsigned int    _size;
00134
00135     // used to tell whether an attribute contains a valid value as well as its type
00136     unsigned int    _flag;
00137 };
00138 #endif  //  DOXYGEN_IGNORE
00139
00140 #endif // _nv_attribute_h_
Generated on Fri Aug 4 08:33:06 2006 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 // Calling convention define required below.
00019 // Note: GLAPI is already defined in gl.h from Mesa 3-D graphics library (Linux build),
00020 // where it is used to specify the linkage and not the calling convention.
00021 #ifdef _WIN32
00022 # define GLAPI __stdcall
00023 #else
00024 # define GLAPI
00025 #endif
00026
00027 // Note: Be sure to define GL_GLEXT_LEGACY when building on Linux with Mesa 3-D headers!
00028 #include "GL/glext.h"   // OpenGL extension
00029 #if defined(_WIN32)
00030 # include "GL/wglext.h" // Microsoft specific OpenGL extensions
00031 #elif defined(LINUX)
00032 # include "GL/glx.h"
00033 # include "nvgl/glxtypes.h"
00034 # include <pthread.h>
00035 #endif
00036
00037 // STL header
00038 #include <map>
00039
00040 // GL error tracing macro
00041 #if !defined(NDEBUG) && !defined(NVSG_HYBRID)
00042 # define ASSERT_GL_NO_ERROR               NVSG_ASSERT( ( glError = glGetError() ) == GL_NO_ERROR )
00043 # define ASSERT_GL_NO_ERROR_IN_BEGIN_END  NVSG_ASSERT( glContext()->m_inBeginEndLoop || ( glError = glGetError() ) == GL_NO_ERROR )
00044 #else
00045 # define ASSERT_GL_NO_ERROR
00046 # define ASSERT_GL_NO_ERROR_IN_BEGIN_END
00047 #endif
00048
00050
00058 namespace nvgl
00059 {
00060   class GLContext;
00061
00062 #if defined(_WIN32)
00063   extern  NVSG_API DWORD glContextTlsIdx;
00064 #elif defined(LINUX)
00065   extern  NVSG_API pthread_key_t glContextKey;
00066 #else
00067 #error Unsupported Operating System!
00068 #endif
00069
00070 #if !defined(NDEBUG)
00071   extern  NVSG_API GLenum  glError;
00072 #endif
00073 }
00074
00075
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:33:06 2006 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 // Linux type defines
00020 #if defined(LINUX)
00021 #include "nvsg/LinuxTypes.h"
00022 #endif
00023
00024 // project header
00025 #include "nvsg/nvsgapi.h"  // storage-class defines
00026 #include "nvutil/Assert.h" // assert
00027 #include "nvutil/Trace.h"  // support for function level tracing
00028 #include "nvutil/Log.h"    // logging
00029 #include "nvutil/nvutil.h" // utility CRT functions
Generated on Fri Aug 4 08:33:06 2006 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 Fri Aug 4 08:33:06 2006 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
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


PrimitiveSetCombineTraverser.h Source File

PrimitiveSetCombineTraverser.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 <list>
00015
00016 #include "nvsgcommon.h"
00017
00018 #include "nvsg/nvsg.h"
00019 #include "nvsg/Face.h"
00020 #include "nvsg/IndependentPrimitiveSet.h"
00021 #include "nvsg/MeshedPrimitiveSet.h"
00022 #include "nvsg/StrippedPrimitiveSet.h"
00023 #include "nvtraverser/OptimizeTraverser.h"
00024
00025 namespace nvtraverser
00026 {
00028
00029   class PrimitiveSetCombineTraverser : public OptimizeTraverser
00030   {
00031     public:
00033       NVSG_API PrimitiveSetCombineTraverser( void );
00034
00036
00039       NVSG_API bool getIgnoreShares( void ) const;
00040
00042
00044       NVSG_API void setIgnoreShares( bool ignore
00045                                    );
00046
00048
00051       NVSG_API size_t getMaxNumberOfVertices() const;
00052
00054
00056       NVSG_API void   setMaxNumberOfVertices( size_t mnov );
00057
00058     protected:
00060       NVSG_API virtual ~PrimitiveSetCombineTraverser( void );
00061
00063       NVSG_API virtual void doApply( const nvsg::Scene * scene );
00064
00066
00067       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p
00068                                          );
00069
00071
00072       NVSG_API virtual void handleLines( const nvsg::Lines * p
00073                                        );
00074
00076
00077       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips * p
00078                                             );
00079
00081
00082       NVSG_API virtual void handlePoints( const nvsg::Points * p
00083                                         );
00084
00086
00087       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes * p
00088         );
00089
00091
00092       NVSG_API virtual void handleQuads( const nvsg::Quads * p
00093                                        );
00094
00096
00097       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips * p
00098                                             );
00099
00101
00102       NVSG_API virtual void handleTriangles( const nvsg::Triangles * p
00103                                            );
00104
00106
00107       NVSG_API virtual void handleTriFans( const nvsg::TriFans * p
00108                                          );
00109
00111
00112       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips * p
00113                                            );
00114
00116
00117       NVSG_API virtual void handleStateSet( const nvsg::StateSet * p
00118                                           );
00119
00120     private:
00121       void combine( nvsg::PrimitiveSet *p0, const nvsg::PrimitiveSet *p1 );
00122       void combine( nvsg::IndependentPrimitiveSet *p0, const nvsg::IndependentPrimitiveSet *p1 );
00123       void combine( nvsg::StrippedPrimitiveSet *p0, const nvsg::StrippedPrimitiveSet *p1 );
00124       template<typename T> void combineDrawables( const nvsg::GeoNode *p, std::map<const nvsg::StateSet*,std::vector<std::vector<const T*> > > &mvvT );
00125       void reduceVertexAttributeSet( const nvsg::IndependentPrimitiveSet * p );
00126       void reduceVertexAttributeSet( const nvsg::MeshedPrimitiveSet * p );
00127       void reduceVertexAttributeSet( const nvsg::StrippedPrimitiveSet * p );
00128       const nvsg::VertexAttributeSet * reduceVertexAttributeSet( const nvsg::VertexAttributeSet *p, std::map<unsigned int, unsigned int> &indexMap );
00129       template<typename T> void storeDrawable( const T *p, std::map<const nvsg::StateSet *, std::vector<std::vector<const T *> > > &mvvT );
00130       const nvsg::IndependentPrimitiveSet * simpleCombine( const nvsg::IndependentPrimitiveSet * p0
00131                                                          , const nvsg::IndependentPrimitiveSet * p1 );
00132       const nvsg::MeshedPrimitiveSet * simpleCombine( const nvsg::MeshedPrimitiveSet * p0
00133                                                     , const nvsg::MeshedPrimitiveSet * p1 );
00134       const nvsg::StrippedPrimitiveSet * simpleCombine( const nvsg::StrippedPrimitiveSet * p0
00135                                                       , const nvsg::StrippedPrimitiveSet * p1 );
00136
00137     private:
00138       bool                                                                                      m_ignoreShares;
00139       size_t                                                                                    m_maxNumberOfVertices;
00140       const nvsg::StateSet                                                                    * 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<const nvsg::StateSet *, std::vector<std::vector<const nvsg::Lines *> > >         m_lines;
00144       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::LineStrips *> > >    m_lineStrips;
00145       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::Points *> > >        m_points;
00146       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::QuadMeshes *> > >    m_quadMeshes;
00147       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::Quads *> > >         m_quads;
00148       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::QuadStrips *> > >    m_quadStrips;
00149       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::Triangles *> > >     m_triangles;
00150       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::TriFans *> > >       m_triFans;
00151       std::map<const nvsg::StateSet *, std::vector<std::vector<const nvsg::TriStrips *> > >     m_triStrips;
00152   };
00153
00154
00155   inline bool PrimitiveSetCombineTraverser::getIgnoreShares( void ) const
00156   {
00157     return( m_ignoreShares );
00158   }
00159
00160   inline void PrimitiveSetCombineTraverser::setIgnoreShares( bool ignore )
00161   {
00162     m_ignoreShares = ignore;
00163   }
00164
00165   inline size_t PrimitiveSetCombineTraverser::getMaxNumberOfVertices() const
00166   {
00167     return( m_maxNumberOfVertices );
00168   }
00169
00170   inline void PrimitiveSetCombineTraverser::setMaxNumberOfVertices( size_t mnov )
00171   {
00172     m_maxNumberOfVertices = mnov;
00173   }
00174 }
Generated on Fri Aug 4 08:33:07 2006 for NVSGSDK by NVIDIA


PrimitiveSetUnifyTraverser.h Source File

PrimitiveSetUnifyTraverser.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 "nvtraverser/OptimizeTraverser.h"
00017
00018 namespace nvtraverser
00019 {
00021
00022   class PrimitiveSetUnifyTraverser : public OptimizeTraverser
00023   {
00024     public:
00026       NVSG_API PrimitiveSetUnifyTraverser( void );
00027
00028     protected:
00030       NVSG_API virtual ~PrimitiveSetUnifyTraverser( void );
00031
00033       NVSG_API virtual void doApply( const nvsg::Scene *pScene
00034                                    );
00035
00037       NVSG_API virtual void handleGeoNode( const nvsg::GeoNode * p
00038                                          );
00039
00041       NVSG_API virtual void handleLines( const nvsg::Lines *p
00042                                        );
00043
00045       NVSG_API virtual void handleLineStrips( const nvsg::LineStrips * p
00046                                             );
00047
00049       NVSG_API virtual void handlePoints( const nvsg::Points *p
00050                                         );
00051
00053       NVSG_API virtual void handleQuadMeshes( const nvsg::QuadMeshes *p
00054         );
00055
00057       NVSG_API virtual void handleQuads( const nvsg::Quads *p
00058                                        );
00059
00061       NVSG_API virtual void handleQuadStrips( const nvsg::QuadStrips *p
00062                                             );
00063
00065       NVSG_API virtual void handleTriangles( const nvsg::Triangles *p
00066                                            );
00067
00069       NVSG_API virtual void handleTriFans( const nvsg::TriFans *p
00070                                          );
00071
00073       NVSG_API virtual void handleTriStrips( const nvsg::TriStrips *p
00074                                            );
00075
00076     private:
00077       template<typename T>
00078         void testAndExchange( std::vector<const T *> &v, const T *pT );
00079
00080     private:
00081       const nvsg::GeoNode                   * m_currentGeoNode;
00082       std::vector<const nvsg::Lines *>        m_lines;
00083       std::vector<const nvsg::LineStrips *>   m_lineStrips;
00084       std::vector<const nvsg::Points *>       m_points;
00085       std::vector<const nvsg::QuadMeshes *>   m_quadMeshes;
00086       std::vector<const nvsg::Quads *>        m_quads;
00087       std::vector<const nvsg::QuadStrips *>   m_quadStrips;
00088       std::vector<const nvsg::Triangles *>    m_triangles;
00089       std::vector<const nvsg::TriFans *>      m_triFans;
00090       std::vector<const nvsg::TriStrips *>    m_triStrips;
00091   };
00092
00093 }
Generated on Fri Aug 4 08:33:07 2006 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 Fri Aug 4 08:33:08 2006 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 Fri Aug 4 08:33:09 2006 for NVSGSDK by NVIDIA


VertexAttributeSetUnifyTraverser.h Source File

VertexAttributeSetUnifyTraverser.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 "nvtraverser/OptimizeTraverser.h"
00017
00018 namespace nvtraverser
00019 {
00021
00022   class VertexAttributeSetUnifyTraverser : public OptimizeTraverser
00023   {
00024     public:
00026       NVSG_API VertexAttributeSetUnifyTraverser( void );
00027
00028     protected:
00030       NVSG_API virtual ~VertexAttributeSetUnifyTraverser( void );
00031
00033       NVSG_API virtual void doApply( const nvsg::Scene *pScene );
00034
00035       NVSG_API virtual void traversePrimitiveSet( const nvsg::PrimitiveSet * p );
00036
00037     private:
00038       std::vector<const nvsg::VertexAttributeSet *>  m_vertexAttributeSets;
00039   };
00040
00041 }
Generated on Fri Aug 4 08:33:10 2006 for NVSGSDK by NVIDIA