texDataNd.h Source File

00001 //////////////////////////////////////////////////////////////////////
00002 // 9/6/02       Aaron Lefohn    Scientific Computing and Imaging Institute
00003 // School of Computing          University of Utah
00004 //
00005 //  This library is free software; you can redistribute it and/or
00006 //  modify it under the terms of the GNU Lesser General Public
00007 //  License as published by the Free Software Foundation; either
00008 //  version 2.1 of the License, or (at your option) any later version.
00009 //
00010 //  This library is distributed in the hope that it will be useful,
00011 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013 //  Lesser General Public License for more details.
00014 //
00015 //  You should have received a copy of the GNU Lesser General Public
00016 //  License along with this library; if not, write to the Free Software
00017 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018 
00019 
00020 #ifndef GLIFT_ND_TEXDATA_H_
00021 #define GLIFT_ND_TEXDATA_H_
00022 
00023 #include "texData.h"
00024 #include <mathGutz.h>
00025 #include <arrayGutz.h>
00026 
00027 #ifdef GLIFT_NRRD
00028 #include <nrrd.h>
00029 #endif 
00030 
00031 #include <vector>
00032 
00033 
00034 //TODO: fix the texOrigin in these constructors to match the dimension of the texture they specify
00035 
00036 namespace glift 
00037 {
00038 
00039 /////////////////////////////////////////////////////////////////////////
00040 ///
00041 /// Texture Data classes 
00042 ///    - These are adapter classes between your favorite data \n
00043 ///      structure and the 'TexData' interface.
00044 ///    - It is intended that 'TexData' will be subclassed for any data \n
00045 ///             structures required. These are merely examples for the data structures \n
00046 ///      used in glift.
00047 ///    - WARNING: All are wrapper (shallow-copy) classes
00048 /// 
00049 /// TexDataArr1<T>
00050 ///    - TexData for arrayWrap1<T> data
00051 ///      - Can specify data for 1D, 2D, or 3D texture. Use 2D for cube face
00052 ///      - Template parameter is OpenGL-compatible basic type
00053 ///                        
00054 /// TexDataArr2<T>
00055 ///    - TexData for arrayWrap2<T> data
00056 ///    - Can specify data for 1D, 2D, or 3D texture. Use 2D for cube face
00057 ///    - Template parameter is OpenGL-compatible basic type
00058 ///                                                
00059 /// NrrdTexData
00060 ///    - TexData for Nrrd data
00061 ///    - Can specify data for 1D, 2D, or 3D texture. Use 2D for cube face
00062 ///                
00063 /// TexDataArr1<T>
00064 ///    TexData for arrayWrap1<T> data. 
00065 ///      Template parameter is OpenGL-compatible basic type
00066 ///////////////////////////////////////////////
00067 template <class T>
00068 class _export_ TexDataArr1 : public TexData
00069 {
00070 public:
00071    /// 1D Texture constructors
00072    TexDataArr1( GLenum                      dataFormat, 
00073       GLenum                      dataType, 
00074       int                         size1D, 
00075       const gutz::arrayWrap1<T>&  arr );
00076 
00077    TexDataArr1( int                         texOrigin, 
00078       int                         borderW, 
00079       GLenum                      glFormat, 
00080       GLenum                      dataFormat, 
00081       GLenum                      dataType, 
00082       int                         size1D, 
00083       const gutz::arrayWrap1<T>&  arr  );
00084 
00085    /// 2D Texture constructors
00086    TexDataArr1( GLenum                      dataFormat, 
00087       GLenum                      dataType, 
00088       const gutz::vec2i&          size2D, 
00089       const gutz::arrayWrap1<T>&  arr );
00090 
00091    TexDataArr1( int                         texOrigin, 
00092       int                         borderW, 
00093       GLenum                      glFormat, 
00094       GLenum                      dataFormat, 
00095       GLenum                      dataType, 
00096       const gutz::vec2i&          size2D, 
00097       const gutz::arrayWrap1<T>&  arr );
00098 
00099    /// 3D Texture constructors
00100    TexDataArr1( GLenum                      dataFormat, 
00101       GLenum                      dataType, 
00102       const gutz::vec3i&          size3D, 
00103       const gutz::arrayWrap1<T>&  arr );
00104 
00105    TexDataArr1( int                         texOrigin, 
00106       int                         borderW, 
00107       GLenum                      glFormat, 
00108       GLenum                      dataFormat, 
00109       GLenum                      dataType, 
00110       const gutz::vec3i&          size3D, 
00111       const gutz::arrayWrap1<T>&  arr );
00112 
00113    /// Default copy constructor, assignment operator, and destructor
00114 
00115    /// Accessors
00116    gutz::arrayWrap1<T>& array() const {return m_array;}
00117 
00118 private:
00119    gutz::arrayWrap1<T> m_array;/// arrayWrap1<T> shallow wrapper around input data
00120    TexDataArr1();                                       /// Disallow default construction
00121 };
00122 
00123 ///////////////////////////////////////////////
00124 /// TexDataArr2<T> - TexData for arrayWrap2<T> data
00125 ///                               - Template parameter is OpenGL-compatible basic type
00126 ///                               - Use for 2D textures and CubeMaps
00127 ///////////////////////////////////////////////
00128 template <class T>
00129 class _export_ TexDataArr2 : public TexData
00130 {
00131 public:
00132    /// 1D Texture constructors
00133    TexDataArr2( GLenum                      dataFormat, 
00134       GLenum                      dataType, 
00135       int                         size1D, 
00136       const gutz::arrayWrap2<T>&  arr );
00137 
00138    TexDataArr2( int                         texOrigin, 
00139       int                         borderW, 
00140       GLenum                      glFormat, 
00141       GLenum                      dataFormat, 
00142       GLenum                      dataType, 
00143       int                         size1D, 
00144       const gutz::arrayWrap2<T>&  arr  );
00145 
00146    /// 2D Texture constructors
00147    TexDataArr2( GLenum                      dataFormat, 
00148       GLenum                      dataType, 
00149       const gutz::vec2i&          size2D, 
00150       const gutz::arrayWrap2<T>&  arr );
00151 
00152    TexDataArr2( int                         texOrigin, 
00153       int                         borderW, 
00154       GLenum                      glFormat, 
00155       GLenum                      dataFormat, 
00156       GLenum                      dataType, 
00157       const gutz::vec2i&          size2D, 
00158       const gutz::arrayWrap2<T>&  arr );
00159 
00160    /// 3D Texture constructors
00161    TexDataArr2( GLenum                      dataFormat, 
00162       GLenum                      dataType, 
00163       const gutz::vec3i&          size3D, 
00164       const gutz::arrayWrap2<T>&  arr );
00165 
00166    TexDataArr2( int                         texOrigin, 
00167       int                         borderW, 
00168       GLenum                      glFormat, 
00169       GLenum                      dataFormat, 
00170       GLenum                      dataType, 
00171       const gutz::vec3i&          size3D, 
00172       const gutz::arrayWrap2<T>&  arr );
00173 
00174    /// Default copy constructor, assignment operator, and destructor
00175 
00176    /// Accessors
00177    gutz::arrayWrap2<T>& array() const {return m_array;}
00178 
00179 private:
00180    gutz::arrayWrap2<T> m_array; /// arrayWrap2<T> shallow wrapper around input data
00181    TexDataArr2();                                               /// Disallow default construction
00182 };
00183 
00184 #ifdef GLIFT_NRRD
00185 ///////////////////////////////////////////////
00186 /// NrrdTexData - TexData for Nrrd data
00187 ///                        - Use for 1D, 2D, 3D, or a face of a cube map
00188 ///////////////////////////////////////////////
00189 class _export_ NrrdTexData : public TexData
00190 {
00191 public: 
00192    /// Simple Constructor -  Assume origin=0, glFormat=dataFormat, borderW=0
00193    NrrdTexData( GLenum             texDimenName, 
00194       GLenum dataFormat, Nrrd* data );
00195 
00196    /// Full Constructor - No assumptions
00197    NrrdTexData( GLenum texDimenName, 
00198       const gutz::vec3i&   origin, 
00199       int                  borderW,  
00200       GLenum               glFormat, 
00201       GLenum               dataFormat, 
00202       Nrrd*                data );      
00203 
00204    /// Default copy constructor, assignment operator, and destructor
00205 
00206    /// Accessors
00207    Nrrd* nrrd()  const {return m_nIn;}
00208 
00209 private:
00210    Nrrd*        m_nIn;   //The data
00211 
00212    gutz::vec4i getDimen(Nrrd* nIn);
00213 };
00214 #endif
00215 
00216 /*
00217 ///////////////////////////////////////////////
00218 /// TexDataCube<T> - Cube texData class. 
00219 ///                               - Template parameter is OpenGL-compatible basic type
00220 ///                               - Use for entire CubeMap data. Use TexDataArr2<T> for cube faces.
00221 ///////////////////////////////////////////////
00222 template <class T>
00223 class _export_ TexDataCube<T> : public TexData
00224 {
00225 public:
00226 TexDataCube( GLenum dataFormat, GLenum dataType, 
00227 const gutz::arrayWrap2<T>& arrPX, const gutz::arrayWrap2<T>& arrNX,
00228 const gutz::arrayWrap2<T>& arrPY, const gutz::arrayWrap2<T>& arrNY,
00229 const gutz::arrayWrap2<T>& arrPZ, const gutz::arrayWrap2<T>& arrNZ );
00230 
00231 TexDataCube( const gutz::vec2i& texOrigin, int borderW, 
00232 GLenum glFormat, GLenum dataFormat, GLenum dataType, 
00233 const gutz::arrayWrap2<T>& arrPX, const gutz::arrayWrap2<T>& arrNX,
00234 const gutz::arrayWrap2<T>& arrPY, const gutz::arrayWrap2<T>& arrNY,
00235 const gutz::arrayWrap2<T>& arrPZ, const gutz::arrayWrap2<T>& arrNZ );
00236 
00237 /// Typdefs
00238 typedef ArrGLI::ArrayW2<T> ArrW2;
00239 typedef std::vector<ArrW2> VecArrW2;
00240 
00241 /// Accessors
00242 VecArrW2&       array()   const { return m_data; }
00243 ArrW2&          arrayPX() const { return m_data[0]; }
00244 ArrW2&          arrayNX() const { return m_data[1]; }
00245 ArrW2&          arrayPY() const { return m_data[2]; }
00246 ArrW2&          arrayNY() const { return m_data[3]; }
00247 ArrW2&          arrayPZ() const { return m_data[4]; }
00248 ArrW2&          arrayNZ() const { return m_data[5]; }
00249 
00250 private:
00251 VecArrW2        m_data;         /// The data. m_data[cubeFace][i][j]
00252 VecTexDataP     m_texData;      /// The TexData objects
00253 
00254 TexDataCube();                  /// Dissallow default construction
00255 };
00256 */
00257 
00258 ///////////////////////////////////////////////////////////////
00259 /// Implementation - Everything below this point is
00260 ///                                     implementation for the template classses.
00261 ///////////////////////////////////////////////////////////////
00262 
00263 /////////////////////////////////////////////////////////////////////////
00264 ///                                             TexDataArr1<T>
00265 /////////////////////////////////////////////////////////////////////////
00266 
00267 /// 1D Texture constructors
00268 template <class T>
00269 TexDataArr1<T>::TexDataArr1( GLenum dataFormat, GLenum dataType, int size1D, const gutz::arrayWrap1<T>& arr )
00270 : m_array( arr ),
00271 TexData( GL_TEXTURE_1D,  gutz::vec3i(0), gutz::vec3i(size1D, 0, 0),
00272         0, dataFormat, dataFormat, dataType, (void*)arr.data() )
00273 {}
00274 
00275 template <class T>
00276 TexDataArr1<T>::TexDataArr1( int texOrigin, int borderW, GLenum glFormat, GLenum dataFormat, 
00277                             GLenum dataType, int size1D, const gutz::arrayWrap1<T>& arr )
00278                             : m_array( arr ),
00279                             TexData( GL_TEXTURE_1D, gutz::vec3i(texOrigin, 0, 0), gutz::vec3i(size1D, 0, 0),
00280                             borderW, glFormat, dataFormat, dataType, (void*)arr.data() )
00281 {}
00282 
00283 /// 2D Texture constructors
00284 template <class T>
00285 TexDataArr1<T>::TexDataArr1( GLenum dataFormat, GLenum dataType, const gutz::vec2i& size2D, const gutz::arrayWrap1<T>& arr )
00286 : m_array( arr ),
00287 TexData( GL_TEXTURE_2D,  gutz::vec3i(0), gutz::vec3i(size2D.x, size2D.y, 0),
00288         0, dataFormat, dataFormat, dataType, (void*)arr.data() )
00289 {}
00290 
00291 template <class T>
00292 TexDataArr1<T>::TexDataArr1( int texOrigin, int borderW, GLenum glFormat, GLenum dataFormat, 
00293                             GLenum dataType, const gutz::vec2i& size2D, const gutz::arrayWrap1<T>& arr )
00294                             : m_array( arr ),
00295                             TexData( GL_TEXTURE_2D, gutz::vec3i(texOrigin, 0, 0), gutz::vec3i(size2D.x, size2D.y, 0),
00296                             borderW, glFormat, dataFormat, dataType, (void*)arr.data() )
00297 {}
00298 
00299 /// 3D Texture constructors
00300 template <class T>
00301 TexDataArr1<T>::TexDataArr1( GLenum dataFormat, GLenum dataType, const gutz::vec3i& size3D, const gutz::arrayWrap1<T>& arr )
00302 : m_array( arr ),
00303 TexData( GL_TEXTURE_3D_EXT,  gutz::vec3i(0), size3D,
00304         0, dataFormat, dataFormat, dataType, (void*)arr.data() )
00305 {}
00306 
00307 template <class T>
00308 TexDataArr1<T>::TexDataArr1( int texOrigin, int borderW, GLenum glFormat, GLenum dataFormat, 
00309                             GLenum dataType, const gutz::vec3i& size3D, const gutz::arrayWrap1<T>& arr )
00310                             : m_array( arr ),
00311                             TexData( GL_TEXTURE_3D_EXT, gutz::vec3i(texOrigin, 0, 0), size3D,
00312                             borderW, glFormat, dataFormat, dataType, (void*)arr.data() )
00313 {}
00314 
00315 
00316 /////////////////////////////////////////////////////////////////////////
00317 ///                                             TexDataArr2<T>
00318 /////////////////////////////////////////////////////////////////////////
00319 /// 1D Texture constructors
00320 template <class T>
00321 TexDataArr2<T>::TexDataArr2( GLenum dataFormat, GLenum dataType, int size1D, const gutz::arrayWrap2<T>& arr )
00322 : m_array( arr ),
00323 TexData( GL_TEXTURE_1D,  gutz::vec3i(0), gutz::vec3i(size1D, 0, 0),
00324         0, dataFormat, dataFormat, dataType, (void*)arr.data() )
00325 {}
00326 
00327 template <class T>
00328 TexDataArr2<T>::TexDataArr2( int texOrigin, int borderW, GLenum glFormat, GLenum dataFormat, 
00329                             GLenum dataType, int size1D, const gutz::arrayWrap2<T>& arr )
00330                             : m_array( arr ),
00331                             TexData( GL_TEXTURE_1D, gutz::vec3i(texOrigin, 0, 0), gutz::vec3i(size1D, 0, 0),
00332                             borderW, glFormat, dataFormat, dataType, (void*)arr.data() )
00333 {}
00334 
00335 /// 2D Texture constructors
00336 template <class T>
00337 TexDataArr2<T>::TexDataArr2( GLenum dataFormat, GLenum dataType, const gutz::vec2i& size2D, const gutz::arrayWrap2<T>& arr )
00338 : m_array( arr ),
00339 TexData( GL_TEXTURE_2D,  gutz::vec3i(0), gutz::vec3i(size2D.x, size2D.y, 0),
00340         0, dataFormat, dataFormat, dataType, (void*)arr.data() )
00341 {}
00342 
00343 template <class T>
00344 TexDataArr2<T>::TexDataArr2( int texOrigin, int borderW, GLenum glFormat, GLenum dataFormat, 
00345                             GLenum dataType, const gutz::vec2i& size2D, const gutz::arrayWrap2<T>& arr )
00346                             : m_array( arr ),
00347                             TexData( GL_TEXTURE_2D, gutz::vec3i(texOrigin, 0, 0), gutz::vec3i(size2D.x, size2D.y, 0),
00348                             borderW, glFormat, dataFormat, dataType, (void *)arr.data() )
00349 {}
00350 
00351 /// 3D Texture constructors
00352 template <class T>
00353 TexDataArr2<T>::TexDataArr2( GLenum dataFormat, GLenum dataType, const gutz::vec3i& size3D, const gutz::arrayWrap2<T>& arr )
00354 : m_array( arr ),
00355 TexData( GL_TEXTURE_3D_ARB,  gutz::vec3i(0), size3D,
00356         0, dataFormat, dataFormat, dataType, (void*)arr.data() )
00357 {}
00358 
00359 template <class T>
00360 TexDataArr2<T>::TexDataArr2( int texOrigin, int borderW, GLenum glFormat, GLenum dataFormat, 
00361                             GLenum dataType, const gutz::vec3i& size3D, const gutz::arrayWrap2<T>& arr )
00362                             : m_array( arr ),
00363                             TexData( GL_TEXTURE_3D_ARB, gutz::vec3i(texOrigin, 0, 0), size3D,
00364                             borderW, glFormat, dataFormat, dataType, (void*)arr.data() )
00365 {}
00366 
00367 /*
00368 ////////////////////////////
00369 /// TexDataCube
00370 ////////////////////////////
00371 template <class T>
00372 TexDataCube<T>::TexDataCube( GLenum dataFormat, GLenum dataType, 
00373 const gutz::arrayWrap2<T>& arrPX, const gutz::arrayWrap2<T>& arrNX,
00374 const gutz::arrayWrap2<T>& arrPY, const gutz::arrayWrap2<T>& arrNY,
00375 const gutz::arrayWrap2<T>& arrPZ, const gutz::arrayWrap2<T>& arrNZ )
00376 :  m_data(    std::vector<ArrayW2<T>>(6) )
00377 m_texData( std::vector<TexData*>(6)   )
00378 {
00379 m_data[0] = gutz::ArrayW2<T>( arrPX );
00380 m_data[1] = gutz::ArrayW2<T>( arrNX );
00381 m_data[2] = gutz::ArrayW2<T>( arrPY );
00382 m_data[3] = gutz::ArrayW2<T>( arrNY );
00383 m_data[4] = gutz::ArrayW2<T>( arrPZ );
00384 m_data[5] = gutz::ArrayW2<T>( arrNZ );
00385 
00386 for(int i=0; i < m_data.size(); i++) {
00387 m_texData[i] = new TexData( GL_TEXTURE_2D, gutz::vec3i(0), 
00388 gutz::vec3i(m_data[i].dim(0), m_data[i].dim(1), 0),
00389 0, dataFormat, dataFormat, dataType, m_data[i].data() );
00390 }
00391 }
00392 
00393 template <class T>
00394 TexDataCube<T>::TexDataCube( const gutz::vec2i& texOrigin, int borderW, 
00395 GLenum glFormat, GLenum dataFormat, GLenum dataType, 
00396 const gutz::arrayWrap2<T>& arrPX, const gutz::arrayWrap2<T>& arrNX,
00397 const gutz::arrayWrap2<T>& arrPY, const gutz::arrayWrap2<T>& arrNY,
00398 const gutz::arrayWrap2<T>& arrPZ, const gutz::arrayWrap2<T>& arrNZ )
00399 : m_data(    std::vector<ArrayW2<T>>(6) )
00400 m_texData( std::vector<TexData*>(6)   )
00401 {
00402 m_data[0] = gutz::ArrayW2<T>( arrPX );
00403 m_data[1] = gutz::ArrayW2<T>( arrNX );
00404 m_data[2] = gutz::ArrayW2<T>( arrPY );
00405 m_data[3] = gutz::ArrayW2<T>( arrNY );
00406 m_data[4] = gutz::ArrayW2<T>( arrPZ );
00407 m_data[5] = gutz::ArrayW2<T>( arrNZ );
00408 
00409 for(int i=0; i < m_data.size(); i++) {
00410 m_texData[i] = new TexData( GL_TEXTURE_2D, gutz::vec3i(texOrigin.w, texOrigin.h, 0), 
00411 gutz::vec3i(m_data[i].dim(0), m_data[i].dim(1), 0),
00412 borderW, glFormat, dataFormat, dataType, m_data[i].data() );
00413 }
00414 }
00415 */
00416 
00417 } /// End of namespace glift
00418 #endif
00419