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

GeoSet.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2004
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 
00011 
00012 #pragma once
00013 
00015 #include "nvsgcommon.h"
00016 
00017 #include <map>
00018 #include "nvmath/BoundingSphere.h"
00019 #include "nvsg/Drawable.h"
00020 #include "nvsg/HighlightObject.h"
00021 
00022 #ifdef _DEBUG
00023 # ifndef new
00024 #  define new new(__FILE__, __LINE__)
00025 #  define _DEFINED_DBGNEW // restrict the 'new' macro to this header file only
00026 # endif
00027 #endif
00028 
00029 
00030 namespace nvsg
00031 {
00032   //  forward declarations
00033   class GeoSet;
00034 
00036 
00037   typedef enum
00038   {
00039     TCT_CYLINDRICAL,      
00040     TCT_PLANAR,           
00041     TCT_SPHERICAL,        
00042   } TextureCoordType;
00043 
00044 // VertexAttrib serves as a private helper class providing data management (so no need for docs)
00045 # if ! defined( DOXYGEN_IGNORE )
00046   class VertexAttrib
00047   {
00048     public:
00049       // default constructs a VertexAttrib object
00050       VertexAttrib();
00051       // cleanup on destruction
00052       ~VertexAttrib();
00053       // Copies float data pointed to by fdata to the vertex attribute's internal data storage.
00054       // fdim specifies the dimension, in terms of float, of a single data element.
00055       // count specifies the number of data elements to be copied, so that always
00056       // count * fdim floats are copied to the internal data storage.
00057       // Behavior is undefined if fdata is an invalid pointer.
00058       void setData(unsigned int fdim, const float * fdata, size_t count);
00059       // Overrides the data element at position pos with the data element pointed to by fdata.
00060       // Behavior is undefined if either the specified position is invalid, or if fdata is an invalid pointer.
00061       // Behavior also is undefined if fdim doesn't match the dimension of the data element currently stored
00062       // at the specified position.
00063       void setData(unsigned int fdim, size_t pos, const float * fdata, size_t count);
00064       // Returns a pointer to the float data stored in this vertex attrib, 
00065       // or a NULL pointer if no data is currently strored
00066       const float * getData() const;
00067       // Returns the dimension, in terms of float, of the stored data.
00068       // If no data is stored in this vertex attrib, the return value might be random. 
00069       unsigned int getDataDim() const;
00070       // Returns the number of data elements currently stored in this vertex attribute
00071       size_t getNumberOfData() const;
00072 
00073     private:
00074       unsigned int m_fdim; // dimension of data elements in terms of float
00075       std::vector<float> m_fdata; // float data storage (contiguous memory)
00076       size_t m_count; // number of data elements (==m_fdata.size()/m_fdim)
00077                       // serves as a cache to improve performance when querying the current data count
00078   };
00079 
00080   inline const float * VertexAttrib::getData() const
00081   {
00082     __TRACE();
00083     return !m_fdata.empty() ? &m_fdata[0] : NULL; 
00084   }
00085 
00086   inline unsigned int VertexAttrib::getDataDim() const
00087   {
00088     __TRACE();
00089     __ASSERT(m_fdata.empty() || !(m_fdata.size()%m_fdim)); // this would be a serious error! 
00090     __ASSERT(m_fdata.empty() == !m_fdim);
00091     return m_fdim;
00092   }
00093 
00094   inline size_t VertexAttrib::getNumberOfData() const
00095   {
00096     __TRACE();
00097     __ASSERT(m_fdata.empty() == !m_fdim);
00098     __ASSERT(m_fdata.empty() || !(m_fdata.size()%m_fdim)); // this would be a serious error
00099     __ASSERT(m_fdata.empty() || m_count==m_fdata.size()/m_fdim); // count cache is not up to data
00100                                                                // --> serious, as well
00101     return m_count;
00102   }
00103 #endif    //  DOXYGEN_IGNORE
00104 
00106 
00109   class GeoSet : public Drawable
00110   {
00111     friend class CachedGeometry;
00112 
00113     public:
00115 
00116       enum 
00117       {
00118         VERTEX_POSITION  = 0,
00119         VERTEX_WEIGHTS,
00120         NORMAL,
00121         PRIMARY_COLOR,
00122         SECONDARY_COLOR,
00123         FOG_COORDINATE,
00124         UNUSED_1,
00125         UNUSED_2,
00126         TEXTURE_COORD_0,
00127         TEXTURE_COORD_1,
00128         TEXTURE_COORD_2,
00129         TEXTURE_COORD_3,
00130         TEXTURE_COORD_4,
00131         TEXTURE_COORD_5,
00132         TEXTURE_COORD_6,
00133         TEXTURE_COORD_7,
00134         NUMBER_OF_VERTEX_ATTRIBUTES
00135       };
00136 
00138 
00139       NVSG_API virtual bool isDataShared( void ) const;
00140 
00142 
00143       NVSG_API virtual DataID getDataID( void ) const;
00144 
00146 
00148       NVSG_API bool isBoundingSphereValid( void ) const;
00149 
00151 
00154       NVSG_API const nvmath::Sphere3f & getBoundingSphere( void ) const;
00155 
00157 
00177       NVSG_API size_t getNumberOfVertexAttributeBytes( size_t attrib    
00178                                                      ) const;
00179 
00181 
00202       NVSG_API const float * getVertexAttributeData( size_t attrib    
00203                                                    ) const;
00204 
00206 
00230       NVSG_API unsigned int getVertexAttributeDataDim( size_t attrib    
00231                                                      ) const;
00232 
00234 
00254       NVSG_API size_t getNumberOfVertexAttributeData( size_t attrib   
00255                                                     ) const;
00256 
00258 
00283       NVSG_API void setVertexAttributeData( size_t attrib         
00284                                           , unsigned int fdim     
00285                                           , const float * fdata   
00286                                           , size_t count          
00287                                           );
00288 
00290 
00325       NVSG_API void setVertexAttributeData( size_t attrib         
00326                                           , unsigned int fdim     
00327                                           , size_t pos            
00328                                           , const float * fdata   
00329                                           , size_t count          
00330                                           );
00332 
00334       NVSG_API size_t getNumberOfVertices( void ) const;
00335 
00337 
00341       NVSG_API const nvmath::Vec3f * getVertices( void ) const;
00342 
00344 
00348       NVSG_API void setVertices( const nvmath::Vec3f * verts                    
00349                                , size_t count                           
00350                                );
00351 
00353 
00367       NVSG_API void setVertices( size_t pos                             
00368                                , const nvmath::Vec3f * verts            
00369                                , size_t count                           
00370                                );
00371        
00373 
00375       NVSG_API size_t getNumberOfNormals( void ) const;
00376 
00378 
00382       NVSG_API const nvmath::Vec3f * getNormals( void ) const;
00383 
00385 
00390       NVSG_API void setNormals( const nvmath::Vec3f* nor    
00391                               , size_t count        
00392                               );
00393 
00395 
00409       NVSG_API void setNormals( size_t pos                 
00410                               , const nvmath::Vec3f * nor  
00411                               , size_t count               
00412                               );
00413 
00415 
00416       NVSG_API bool hasTexCoords( void ) const;
00417 
00419 
00423       NVSG_API size_t getNumberOfTexCoords( size_t texUnit    
00424                                           ) const;
00425 
00427 
00432       NVSG_API const float * getTexCoords( size_t texUnit   
00433                                          ) const;
00434 
00436 
00441       NVSG_API unsigned int getTexCoordsDim( size_t texUnit   
00442                                            ) const;
00443 
00445 
00451       NVSG_API void setTexCoords( size_t texUnit          
00452                                 , unsigned int fdim       
00453                                 , const float * coords    
00454                                 , size_t count            
00455                                 );
00456 
00458 
00476       NVSG_API void setTexCoords( size_t texUnit          
00477                                 , unsigned int fdim       
00478                                 , size_t pos              
00479                                 , const float * coords    
00480                                 , size_t count            
00481                                 );
00482 
00484 
00489       NVSG_API void generateTexCoords( TextureCoordType tct             
00490                                       , const nvmath::Sphere3f &sphere  
00491                                       , size_t tu = 0                   
00492                                       );
00493       
00495 
00496       NVSG_API size_t getNumberOfColors( void ) const;
00497 
00499 
00503       NVSG_API const float * getColors( void ) const;
00504 
00506 
00510       NVSG_API unsigned int getColorsDim( void ) const;
00511 
00513 
00518       NVSG_API void setColors( unsigned int fdim    
00519                              , const float * cols   
00520                              , size_t count         
00521                              );
00522 
00524 
00541       NVSG_API void setColors( unsigned int fdim    
00542                              , size_t pos           
00543                              , const float * cols   
00544                              , size_t count         
00545                              );
00546 
00548 
00549       NVSG_API size_t getNumberOfSecondaryColors( void ) const;
00550 
00552 
00553       NVSG_API const float * getSecondaryColors( void ) const;
00554 
00556 
00558       NVSG_API unsigned int getSecondaryColorsDim( void ) const;
00559 
00561 
00566       NVSG_API void setSecondaryColors( unsigned int fdim     
00567                                       , const float * cols    
00568                                       , size_t count          
00569                                       );
00570 
00572 
00589       NVSG_API void setSecondaryColors( unsigned int fdim    
00590                                       , size_t pos           
00591                                       , const float * cols   
00592                                       , size_t count         
00593                                       );
00594 
00596 
00597       NVSG_API size_t getNumberOfFogCoords( void ) const;
00598 
00600 
00601       NVSG_API const float * getFogCoords( void ) const;
00602 
00604 
00607       NVSG_API void setFogCoords( const float * coords    
00608                                 , size_t count            
00609                                 );
00610 
00612 
00627       NVSG_API void setFogCoords( size_t pos              
00628                                 , const float * coords    
00629                                 , size_t count            
00630                                 );
00631 
00633 
00635       NVSG_API virtual void  calculateTangentSpace( size_t tu = 0   
00636                                                   , size_t tg = 1   
00637                                                   , size_t bn = 2   
00638                                                   ) = 0;
00639 
00641 
00642       NVSG_API void attachHighlightObject( const HighlightObject* pObj = NULL ) const;
00643 
00645 
00646       NVSG_API const HighlightObject* getHighlightObject( void ) const;
00647 
00648     protected:
00650 
00653       NVSG_API GeoSet( void );
00654 
00656 
00659       NVSG_API GeoSet( const GeoSet& rhs );
00660 
00662       NVSG_API virtual ~GeoSet( void );
00663 
00665 
00668       NVSG_API virtual void onSetVertexAttributeData( void );
00669 
00671       NVSG_API virtual void invalidateBoundingSphere( void ) const;
00672 
00673     private:      
00674         // implementation details
00675       void generateTexCoordsCylinder( const nvmath::Sphere3f &sphere, size_t tu = 0 );
00676       void generateTexCoordsPlane( const nvmath::Sphere3f &sphere, size_t tu = 0 );
00677       void generateTexCoordsSphere( const nvmath::Sphere3f &sphere, size_t tu = 0 );
00678       void _validateBoundingSphere( void ) const;
00679 
00680       nvutil::RCPtr<nvutil::RCVector<VertexAttrib> >            m_vertexAttribs;    // shareable vertex attribs
00681       mutable nvmath::BoundingSphere                    m_boundingSphere;   // geometry's bounds
00682       mutable const HighlightObject *                  m_highlightObject;       
00683   };
00684 
00685   inline const float * GeoSet::getVertexAttributeData( size_t attrib ) const
00686   {
00687     __TRACE();
00688     __ASSERT(attrib < NUMBER_OF_VERTEX_ATTRIBUTES );
00689     return (*m_vertexAttribs)[attrib].getData();
00690   }
00691 
00692   inline size_t GeoSet::getNumberOfVertexAttributeData( size_t attrib ) const
00693   {
00694     __TRACE();
00695     __ASSERT(attrib < NUMBER_OF_VERTEX_ATTRIBUTES);
00696     return (*m_vertexAttribs)[attrib].getNumberOfData();
00697   }
00698 
00699   inline unsigned int GeoSet::getVertexAttributeDataDim( size_t attrib ) const
00700   {
00701     __TRACE();
00702     __ASSERT(attrib < NUMBER_OF_VERTEX_ATTRIBUTES );
00703     return (*m_vertexAttribs)[attrib].getDataDim();
00704   }
00705 
00706   inline size_t GeoSet::getNumberOfVertices( void ) const 
00707   {
00708     __TRACE();
00709     return getNumberOfVertexAttributeData(VERTEX_POSITION);
00710   }
00711 
00712   inline const nvmath::Vec3f * GeoSet::getVertices( void )  const
00713   {
00714     __TRACE();
00715     return (const nvmath::Vec3f *)getVertexAttributeData(VERTEX_POSITION);
00716   }
00717 
00718   inline void GeoSet::setVertices( const nvmath::Vec3f * verts, size_t count )
00719   {
00720     __TRACE();
00721     setVertexAttributeData(VERTEX_POSITION, 3, (const float*)verts, count);
00722 
00723     if(m_highlightObject)
00724     {
00725       // the highlight object needs to be recalculated
00726       HighlightObject * hlobj = beginEdit( m_highlightObject );
00727       hlobj->invalidate();
00728       endEdit( hlobj );
00729     }
00730   }
00731 
00732   inline void GeoSet::setVertices( size_t pos, const nvmath::Vec3f * verts, size_t count )
00733   {
00734     __TRACE();
00735     setVertexAttributeData(VERTEX_POSITION, 3, pos, (const float*)verts, count);
00736 
00737     if(m_highlightObject)
00738     {
00739       // the highlight object needs to be recalculated
00740       HighlightObject * hlobj = beginEdit( m_highlightObject );
00741       hlobj->invalidate();
00742       endEdit( hlobj );
00743     }
00744   }
00745 
00746   inline size_t GeoSet::getNumberOfNormals( void ) const 
00747   {
00748     __TRACE();
00749     return getNumberOfVertexAttributeData(NORMAL);
00750   }
00751 
00752   inline const nvmath::Vec3f * GeoSet::getNormals( void ) const 
00753   {
00754     __TRACE();
00755     return (const nvmath::Vec3f *)getVertexAttributeData(NORMAL);
00756   }
00757 
00758   inline void GeoSet::setNormals( const nvmath::Vec3f * nor, size_t count )
00759   {
00760     __TRACE();
00761     setVertexAttributeData(NORMAL, 3, (const float*)nor, count);
00762                                  //^ normals always are 3-dimensional
00763   }
00764 
00765   inline void GeoSet::setNormals( size_t pos, const nvmath::Vec3f * nor, size_t count )
00766   {
00767     __TRACE();
00768     setVertexAttributeData(NORMAL, 3, pos, (const float*)nor, count );
00769   }
00770 
00771   inline bool GeoSet::hasTexCoords( void ) const
00772   {
00773     __TRACE();
00774     return(  getNumberOfVertexAttributeData(TEXTURE_COORD_0)
00775           || getNumberOfVertexAttributeData(TEXTURE_COORD_1)
00776           || getNumberOfVertexAttributeData(TEXTURE_COORD_2)
00777           || getNumberOfVertexAttributeData(TEXTURE_COORD_3)
00778           || getNumberOfVertexAttributeData(TEXTURE_COORD_4)
00779           || getNumberOfVertexAttributeData(TEXTURE_COORD_5)
00780           || getNumberOfVertexAttributeData(TEXTURE_COORD_6)
00781           || getNumberOfVertexAttributeData(TEXTURE_COORD_7) );
00782   }
00783 
00784   inline size_t GeoSet::getNumberOfTexCoords( size_t texUnit ) const
00785   {
00786     __TRACE();
00787     __ASSERT(texUnit <= 7);
00788     return getNumberOfVertexAttributeData(TEXTURE_COORD_0+texUnit);
00789   }
00790 
00791   inline const float * GeoSet::getTexCoords( size_t texUnit ) const
00792   {
00793     __TRACE();
00794     __ASSERT(texUnit <= 7);
00795     return getVertexAttributeData(TEXTURE_COORD_0+texUnit);
00796   }
00797 
00798   inline unsigned int GeoSet::getTexCoordsDim( size_t texUnit ) const
00799   {
00800     __TRACE();
00801     __ASSERT(texUnit <= 7);
00802     return getVertexAttributeDataDim(TEXTURE_COORD_0+texUnit);
00803   }
00804 
00805   inline void GeoSet::setTexCoords( size_t texUnit, unsigned int fdim, const float* coords, size_t count )
00806   {
00807     __TRACE();
00808     __ASSERT(texUnit <= 7);
00809     setVertexAttributeData(TEXTURE_COORD_0+texUnit, fdim, coords, count);
00810   }
00811 
00812   inline void GeoSet::setTexCoords( size_t texUnit, unsigned int fdim, size_t pos, const float* coords, size_t count )
00813   {
00814     __TRACE();
00815     __ASSERT(texUnit <= 7);
00816     setVertexAttributeData(TEXTURE_COORD_0+texUnit, fdim, pos, coords, count);
00817   }
00818 
00819   inline size_t GeoSet::getNumberOfColors( void ) const
00820   {
00821     __TRACE();
00822     return getNumberOfVertexAttributeData(PRIMARY_COLOR);
00823   }
00824 
00825   inline const float * GeoSet::getColors( void ) const
00826   {
00827     __TRACE();
00828     return getVertexAttributeData(PRIMARY_COLOR);
00829   }
00830 
00831   inline unsigned int GeoSet::getColorsDim( void ) const
00832   {
00833     __TRACE();
00834     return getVertexAttributeDataDim(PRIMARY_COLOR);
00835   }
00836 
00837   inline void GeoSet::setColors( unsigned int fdim, const float * cols, size_t count )
00838   {
00839     __TRACE();
00840     setVertexAttributeData(PRIMARY_COLOR, fdim, cols, count);
00841   }
00842 
00843   inline void GeoSet::setColors( unsigned int fdim, size_t pos, const float * cols, size_t count )
00844   {
00845     __TRACE();
00846     setVertexAttributeData(PRIMARY_COLOR, fdim, pos, cols, count);
00847   }
00848 
00849   inline size_t GeoSet::getNumberOfSecondaryColors( void ) const
00850   {
00851     __TRACE();
00852     return getNumberOfVertexAttributeData(SECONDARY_COLOR);
00853   }
00854 
00855   inline const float * GeoSet::getSecondaryColors( void ) const
00856   {
00857     __TRACE();
00858     return getVertexAttributeData(SECONDARY_COLOR);
00859   }
00860 
00861   inline unsigned int GeoSet::getSecondaryColorsDim( void ) const
00862   {
00863     __TRACE();
00864     return getVertexAttributeDataDim(SECONDARY_COLOR);
00865   }
00866 
00867   inline void GeoSet::setSecondaryColors( unsigned int fdim, const float* cols, size_t count )
00868   {
00869     __TRACE();
00870     setVertexAttributeData(SECONDARY_COLOR, fdim, cols, count);
00871   }
00872 
00873   inline void GeoSet::setSecondaryColors( unsigned int fdim, size_t pos, const float* cols, size_t count )
00874   {
00875     __TRACE();
00876     setVertexAttributeData(SECONDARY_COLOR, fdim, pos, cols, count);
00877   }
00878 
00879   inline size_t GeoSet::getNumberOfFogCoords( void ) const
00880   {
00881     __TRACE();
00882     return getNumberOfVertexAttributeData(FOG_COORDINATE);
00883   }
00884 
00885   inline const float * GeoSet::getFogCoords( void ) const
00886   {
00887     __TRACE();
00888     return getVertexAttributeData(FOG_COORDINATE);
00889   }
00890 
00891   inline void GeoSet::setFogCoords( const float * coords, size_t count )
00892   {
00893     __TRACE();
00894     setVertexAttributeData(FOG_COORDINATE, 1, coords, count);
00895                                          //^ fog coords always are 1-dimensional
00896   }
00897 
00898   inline void GeoSet::setFogCoords( size_t pos, const float * coords, size_t count )
00899   {
00900     __TRACE();
00901     setVertexAttributeData(FOG_COORDINATE, 1, pos, coords, count);
00902                                          //^ fog coords always are 1-dimensional
00903   }
00904 
00905   inline const HighlightObject* GeoSet::getHighlightObject( void ) const
00906   {
00907     __TRACE();
00908     return m_highlightObject;
00909   }
00910 
00911 } //  namespace nvsg
00912 
00913 #ifdef _DEFINED_DBGNEW
00914 # undef new
00915 #endif

Generated on Tue Mar 1 13:19:19 2005 for NVSGSDK by NVIDIA