GLIP-Lib
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
HdlDynamicData.hpp
Go to the documentation of this file.
1 /* ************************************************************************************************************* */
2 /* */
3 /* GLIP-LIB */
4 /* OpenGL Image Processing LIBrary */
5 /* */
6 /* Author : R. Kerviche */
7 /* LICENSE : MIT License */
8 /* Website : glip-lib.net */
9 /* */
10 /* File : HdlTexture.hpp */
11 /* Original Date : August 7th 2010 */
12 /* */
13 /* Description : OpenGL Dynamic Allocator */
14 /* */
15 /* ************************************************************************************************************* */
16 
24 #ifndef __HdlDynamicDataSpecial_INCLUDE__
25 #define __HdlDynamicDataSpecial_INCLUDE__
26 
27  // Include :
28  #include <iostream>
29  #include <cstring>
30  #include <limits>
31  #include <algorithm>
32  #include "Core/Exception.hpp"
33  #include "Core/LibTools.hpp"
34  #include "Core/OglInclude.hpp"
35 
36  namespace Glip
37  {
38  namespace CoreGL
39  {
40 
65  class GLIP_API HdlDynamicData
66  {
67  private :
68  const int rows,
69  columns;
70  const GLenum type,
71  supportingType;
72  const bool floatingPointType,
73  integerType,
74  booleanType,
75  unsignedType;
76 
77  // Forbidden :
78  HdlDynamicData(const HdlDynamicData&);
79 
80  // Tool :
81  static GLenum getRelatedGLSupportingType(const GLenum& t);
82 
83  protected :
84  HdlDynamicData(const GLenum& _type, int _rows=1, int _columns=1);
85 
86  public :
87  virtual ~HdlDynamicData(void);
88 
89  const GLenum& getGLType(void) const;
90  const GLenum& getGLSupportingType(void) const;
91  const bool& isFloatingPointType(void) const;
92  const bool& isIntegerType(void) const;
93  const bool& isBooleanType(void) const;
94  const bool& isUnsignedType(void) const;
95  const int& getNumRows(void) const;
96  const int& getNumColumns(void) const;
97  int getNumElements(void) const;
98  bool isInside(const int& i, const int& j) const;
99  int getIndex(const int& i, const int& j) const;
100  void getCoordinates(const int& index, int& i, int& j) const;
101 
109  virtual float getf(const int& i=0, const int& j=0) const = 0;
110 
118  virtual void setf(const float& value, const int& i=0, const int& j=0) = 0;
119 
127  virtual double get(const int& i=0, const int& j=0) const = 0;
128 
136  virtual void set(const double& value, const int& i=0, const int& j=0) = 0;
137 
143  virtual const void* getPtr(void) const = 0;
144 
150  virtual void* getPtr(void) = 0;
151 
158  virtual const HdlDynamicData& operator=(const HdlDynamicData& cpy) = 0;
159 
160  #ifdef _WIN32
161  GLIP_API_FUNC friend std::ostream& operator<<(std::ostream& os, const HdlDynamicData& d);
162  #else
163  friend std::ostream& operator<<(std::ostream& os, const HdlDynamicData& d); // Does not support the extern keyword
164  #endif
165 
166  static HdlDynamicData* build(const GLenum& type);
167  static HdlDynamicData* copy(const HdlDynamicData& cpy);
168  };
169 
170  GLIP_API_FUNC std::ostream& operator<<(std::ostream& os, const HdlDynamicData& d);
171 
172  template<typename T>
173  class GLIP_API HdlDynamicDataSpecial : public HdlDynamicData
174  {
175  private :
176  T* data;
177 
178  // Forbidden :
179  HdlDynamicDataSpecial(const HdlDynamicDataSpecial& cpy);
180  const HdlDynamicDataSpecial& operator=(const HdlDynamicDataSpecial& cpy);
181 
182  protected :
183  HdlDynamicDataSpecial(const GLenum& _type, int _rows=1, int _columns=1);
184 
185  friend class HdlDynamicData;
186 
187  public :
188  virtual ~HdlDynamicDataSpecial(void);
189 
190  float getf(const int& i=0, const int& j=0) const;
191  void setf(const float& value, const int& i=0, const int& j=0);
192  double get(const int& i=0, const int& j=0) const;
193  void set(const double& value, const int& i=0, const int& j=0);
194 
195  const void* getPtr(void) const;
196  void* getPtr(void);
197 
198  const HdlDynamicData& operator=(const HdlDynamicData& cpy);
199  };
200 
201  // Template implementation :
202  template<typename T>
203  HdlDynamicDataSpecial<T>::HdlDynamicDataSpecial(const GLenum& _type, int _rows, int _columns)
204  : HdlDynamicData(_type, _rows, _columns),
205  data(NULL)
206  {
207  data = new T[getNumElements()];
208 
209  std::memset(data, 0, getNumElements()*sizeof(T));
210  }
211 
212  template<typename T>
213  HdlDynamicDataSpecial<T>::~HdlDynamicDataSpecial(void)
214  {
215  delete[] data;
216  data = NULL;
217  }
218 
219  template<typename T>
220  float HdlDynamicDataSpecial<T>::getf(const int& i, const int& j) const
221  {
222  if(!isInside(i, j))
223  throw Exception("HdlDynamicDataSpecial<T>::getf - Out of range.", __FILE__, __LINE__, Exception::CoreException);
224  else
225  return static_cast<float>(data[ getIndex(i, j) ]);
226  }
227 
228  template<typename T>
229  void HdlDynamicDataSpecial<T>::setf(const float& value, const int& i, const int& j)
230  {
231  if(!isInside(i, j))
232  throw Exception("HdlDynamicDataSpecial<T>::setf - Out of range.", __FILE__, __LINE__, Exception::CoreException);
233  else
234  data[ getIndex(i, j) ] = static_cast<T>(value);
235  }
236 
237  template<typename T>
238  double HdlDynamicDataSpecial<T>::get(const int& i, const int& j) const
239  {
240  if(!isInside(i, j))
241  throw Exception("HdlDynamicDataSpecial<T>::get - Out of range.", __FILE__, __LINE__, Exception::CoreException);
242  else
243  return static_cast<double>(data[ getIndex(i, j) ]);
244  }
245 
246  template<typename T>
247  void HdlDynamicDataSpecial<T>::set(const double& value, const int& i, const int& j)
248  {
249  if(!isInside(i, j))
250  throw Exception("HdlDynamicDataSpecial<T>::set - Out of range.", __FILE__, __LINE__, Exception::CoreException);
251  else
252  data[ getIndex(i, j) ] = static_cast<T>(value);
253  }
254 
255  template<typename T>
256  const void* HdlDynamicDataSpecial<T>::getPtr(void) const
257  {
258  return reinterpret_cast<void*>(data);
259  }
260 
261  template<typename T>
262  void* HdlDynamicDataSpecial<T>::getPtr(void)
263  {
264  return reinterpret_cast<void*>(data);
265  }
266 
267  template<typename T>
268  const HdlDynamicData& HdlDynamicDataSpecial<T>::operator=(const HdlDynamicData& cpy)
269  {
270  if(cpy.getGLType()!=getGLType())
271  throw Exception("HdlDynamicDataSpecial<T>::operator= - Data types do not match (target : \"" + getGLEnumName(cpy.getGLType()) + "\"; source : \"" + getGLEnumName(cpy.getGLType()) + "\").", __FILE__, __LINE__, Exception::CoreException);
272 
273  std::memcpy(data, cpy.getPtr(), getNumElements()*sizeof(T));
274 
275  return (*this);
276  }
277 
299  class GLIP_API HdlDynamicTable
300  {
301  private :
302  const int rows,
303  columns,
304  slices,
305  alignment;
306  const bool proxy,
307  normalized;
308  const GLenum type;
309 
310  protected :
311  HdlDynamicTable(const GLenum& _type, int _columns, int _rows, int _slices, bool _normalized=false, int _alignment=1, bool _proxy=false);
312 
313  public :
314  virtual ~HdlDynamicTable(void);
315 
316  const GLenum& getGLType(void) const;
317  bool isFloatingPointType(void) const;
318  bool isIntegerType(void) const;
319  bool isBooleanType(void) const;
320  bool isUnsignedType(void) const;
321  const int& getNumRows(void) const;
322  const int& getNumColumns(void) const;
323  const int& getNumSlices(void) const;
324  int getNumElements(void) const;
325  const int& getAlignment(void) const;
326 
332  virtual size_t getElementSize(void) const = 0;
333 
334  size_t getSliceSize(void) const;
335  size_t getRowSize(void) const;
336  size_t getSize(void) const;
337  bool isProxy(void) const;
338  bool isNormalized(void) const;
339  bool isInside(const int& j, const int& i, const int& d) const;
340  int getIndex(const int& j, const int& i, const int& d) const;
341  size_t getOffset(const int& j, const int& i, const int& d) const;
342  size_t getRowOffset(const int& i) const;
343 
352  virtual float getf(const int& j=0, const int& i=0, const int& d=0) const = 0;
353 
362  virtual void setf(const float& value, const int& j=0, const int& i=0, const int& d=0) = 0;
363 
372  virtual double getd(const int& j=0, const int& i=0, const int& d=0) const = 0;
373 
382  virtual void setd(const double& value, const int& j=0, const int& i=0, const int& d=0) = 0;
383 
392  virtual long long getl(const int& j=0, const int& i=0, const int& d=0) const = 0;
393 
402  virtual void setl(const long long& value, const int& j=0, const int& i=0, const int& d=0) = 0;
403 
412  virtual int geti(const int& j=0, const int& i=0, const int& d=0) const = 0;
413 
422  virtual void seti(const int& value, const int& j=0, const int& i=0, const int& d=0) = 0;
423 
432  virtual unsigned char getb(const int& j=0, const int& i=0, const int& d=0) const = 0;
433 
442  virtual void setb(const unsigned char& value, const int& j=0, const int& i=0, const int& d=0) = 0;
443 
452  virtual float getNormalized(const int& j=0, const int& i=0, const int& d=0) const = 0;
453 
462  virtual void setNormalized(const float& value, const int& j=0, const int& i=0, const int& d=0) = 0;
463 
472  virtual void* get(const int& j=0, const int& i=0, const int& d=0) const = 0;
473 
482  virtual void set(void* value, const int& j=0, const int& i=0, const int& d=0) const = 0;
483 
490  virtual float readf(size_t offset) const = 0;
491 
498  virtual void writef(const float& value, size_t offset) = 0;
499 
506  virtual double readd(size_t offset) const = 0;
507 
514  virtual void writed(const double& value, size_t offset) = 0;
515 
522  virtual long long readl(size_t offset) const = 0;
523 
530  virtual void writel(const long long& value, size_t offset) = 0;
531 
538  virtual int readi(size_t offset) const = 0;
539 
546  virtual void writei(const int& value, size_t offset) = 0;
547 
554  virtual unsigned char readb(size_t offset) const = 0;
555 
562  virtual void writeb(const unsigned char& value, size_t offset) = 0;
563 
570  virtual float readNormalized(size_t offset) const = 0;
571 
578  virtual void writeNormalized(const float& value, size_t offset) = 0;
579 
586  virtual void write(const void* value, size_t offset) = 0;
587 
588  void writeBytes(const void* value, size_t length, size_t offset);
589 
595  virtual const void* getPtr(void) const = 0;
596 
602  virtual void* getPtr(void) = 0;
603 
610  virtual const void* getRowPtr(int i) const = 0;
611 
618  virtual void* getRowPtr(int i) = 0;
619 
626  virtual const HdlDynamicTable& operator=(const HdlDynamicTable& cpy) = 0;
627 
628  void memset(unsigned char c);
629 
630  static HdlDynamicTable* build(const GLenum& type, const int& _columns, const int& _rows, const int& _slices, bool _normalized=false, int _alignment=1);
631  static HdlDynamicTable* buildProxy(void* buffer, const GLenum& type, const int& _columns, const int& _rows, const int& _slices, bool _normalized=false, int _alignment=1);
632  static HdlDynamicTable* copy(const HdlDynamicTable& cpy);
633  };
634 
635  template<typename T>
636  class GLIP_API HdlDynamicTableSpecial : public HdlDynamicTable
637  {
638  private :
639  unsigned char* data;
640 
641  // Forbidden :
642  HdlDynamicTableSpecial(const HdlDynamicTableSpecial& cpy);
643  const HdlDynamicTableSpecial& operator=(const HdlDynamicTableSpecial& cpy);
644 
645  protected :
646  HdlDynamicTableSpecial(const GLenum& _type, int _columns=1, int _rows=1, int _slices=1, bool _normalized=false, int _alignment=1);
647  HdlDynamicTableSpecial(void* _data, const GLenum& _type, int _columns=1, int _rows=1, int _slices=1, bool _normalized=false, int _alignment=1);
648 
649  friend class HdlDynamicTable;
650 
651  public :
652  virtual ~HdlDynamicTableSpecial(void);
653 
654  size_t getElementSize(void) const;
655 
656  float getf(const int& j=0, const int& i=0, const int& d=0) const;
657  void setf(const float& value, const int& j=0, const int& i=0, const int& d=0);
658  double getd(const int& j=0, const int& i=0, const int& d=0) const;
659  void setd(const double& value, const int& j=0, const int& i=0, const int& d=0);
660  long long getl(const int& j=0, const int& i=0, const int& d=0) const;
661  void setl(const long long& value, const int& j=0, const int& i=0, const int& d=0);
662  int geti(const int& j=0, const int& i=0, const int& d=0) const;
663  void seti(const int& value, const int& j=0, const int& i=0, const int& d=0);
664  unsigned char getb(const int& j=0, const int& i=0, const int& d=0) const;
665  void setb(const unsigned char& value, const int& j=0, const int& i=0, const int& d=0);
666  float getNormalized(const int& j=0, const int& i=0, const int& d=0) const;
667  void setNormalized(const float& value, const int& j=0, const int& i=0, const int& d=0);
668  void* get(const int& j=0, const int& i=0, const int& d=0) const;
669  void set(void* value, const int& j=0, const int& i=0, const int& d=0) const ;
670 
671  float readf(size_t offset) const;
672  void writef(const float& value, size_t offset);
673  double readd(size_t offset) const;
674  void writed(const double& value, size_t offset);
675  long long readl(size_t offset) const;
676  void writel(const long long& value, size_t offset);
677  int readi(size_t offset) const;
678  void writei(const int& value, size_t offset);
679  unsigned char readb(size_t offset) const;
680  void writeb(const unsigned char& value, size_t offset);
681  float readNormalized(size_t offset) const;
682  void writeNormalized(const float& value, size_t offset);
683  void write(const void* value, size_t offset);
684 
685  const void* getPtr(void) const;
686  void* getPtr(void);
687  const void* getRowPtr(int i) const;
688  void* getRowPtr(int i);
689 
690  const HdlDynamicTable& operator=(const HdlDynamicTable& cpy);
691 
692  static float normalize(const T& t);
693  static T denormalize(const float& t);
694  };
695 
696  // Avoid "specialization after instantiation" on some compilers (old g++) :
697  template<>
698  float HdlDynamicTableSpecial<float>::normalize(const float& t);
699 
700  template<>
701  float HdlDynamicTableSpecial<double>::normalize(const double& t);
702 
703  template<>
704  float HdlDynamicTableSpecial<float>::denormalize(const float& t);
705 
706  template<>
707  double HdlDynamicTableSpecial<double>::denormalize(const float& t);
708 
709  // Template implementation :
710  template<typename T>
711  HdlDynamicTableSpecial<T>::HdlDynamicTableSpecial(const GLenum& _type, int _columns, int _rows, int _slices, bool _normalized, int _alignment)
712  : HdlDynamicTable(_type, _columns, _rows, _slices, _normalized, _alignment),
713  data(NULL)
714  {
715  data = new unsigned char[getSize()];
716 
717  std::memset(data, 0, getSize());
718  }
719 
720  template<typename T>
721  HdlDynamicTableSpecial<T>::HdlDynamicTableSpecial(void* _data, const GLenum& _type, int _columns, int _rows, int _slices, bool _normalized, int _alignment)
722  : HdlDynamicTable(_type, _columns, _rows, _slices, _normalized, _alignment, true),
723  data(reinterpret_cast<unsigned char*>(_data))
724  { }
725 
726  template<typename T>
727  HdlDynamicTableSpecial<T>::~HdlDynamicTableSpecial(void)
728  {
729  if(!isProxy())
730  {
731  delete[] data;
732  data = NULL;
733  }
734  }
735 
736  template<typename T>
737  size_t HdlDynamicTableSpecial<T>::getElementSize(void) const
738  {
739  return sizeof(T);
740  }
741 
742  template<typename T>
743  float HdlDynamicTableSpecial<T>::getf(const int& j, const int& i, const int& d) const
744  {
745  if(!isNormalized())
746  return static_cast<float>(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
747  else
748  return HdlDynamicTableSpecial<float>::denormalize(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
749  }
750 
751  template<typename T>
752  void HdlDynamicTableSpecial<T>::setf(const float& value, const int& j, const int& i, const int& d)
753  {
754  if(!isNormalized())
755  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(value);
756  else
757  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = HdlDynamicTableSpecial<float>::normalize(value);
758  }
759 
760  template<typename T>
761  double HdlDynamicTableSpecial<T>::getd(const int& j, const int& i, const int& d) const
762  {
763  if(!isNormalized())
764  return static_cast<double>(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
765  else
766  return HdlDynamicTableSpecial<double>::denormalize(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
767  }
768 
769  template<typename T>
770  void HdlDynamicTableSpecial<T>::setd(const double& value, const int& j, const int& i, const int& d)
771  {
772  if(!isNormalized())
773  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(value);
774  else
775  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = HdlDynamicTableSpecial<double>::normalize(value);
776  }
777 
778  template<typename T>
779  long long HdlDynamicTableSpecial<T>::getl(const int& j, const int& i, const int& d) const
780  {
781  if(!isNormalized())
782  return static_cast<long long>(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
783  else
784  return HdlDynamicTableSpecial<long long>::denormalize(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
785  }
786 
787  template<typename T>
788  void HdlDynamicTableSpecial<T>::setl(const long long& value, const int& j, const int& i, const int& d)
789  {
790  if(!isNormalized())
791  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(value);
792  else
793  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = HdlDynamicTableSpecial<long long>::normalize(value);
794  }
795 
796  template<typename T>
797  int HdlDynamicTableSpecial<T>::geti(const int& j, const int& i, const int& d) const
798  {
799  if(!isNormalized())
800  return static_cast<int>(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
801  else
802  return HdlDynamicTableSpecial<int>::denormalize(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
803  }
804 
805  template<typename T>
806  void HdlDynamicTableSpecial<T>::seti(const int& value, const int& j, const int& i, const int& d)
807  {
808  if(!isNormalized())
809  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(value);
810  else
811  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = HdlDynamicTableSpecial<int>::normalize(value);
812  }
813 
814  template<typename T>
815  unsigned char HdlDynamicTableSpecial<T>::getb(const int& j, const int& i, const int& d) const
816  {
817  if(!isNormalized())
818  return static_cast<unsigned char>(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
819  else
820  return HdlDynamicTableSpecial<unsigned char>::denormalize(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
821  }
822 
823  template<typename T>
824  void HdlDynamicTableSpecial<T>::setb(const unsigned char& value, const int& j, const int& i, const int& d)
825  {
826  if(!isNormalized())
827  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(value);
828  else
829  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = HdlDynamicTableSpecial<unsigned char>::normalize(value);
830  }
831 
832  template<typename T>
833  float HdlDynamicTableSpecial<T>::getNormalized(const int& j, const int& i, const int& d) const
834  {
835  if(!isNormalized())
836  return HdlDynamicTableSpecial<T>::normalize(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
837  else
838  return static_cast<float>(*reinterpret_cast<T*>(data + getOffset(j, i, d)));
839  }
840 
841  template<typename T>
842  void HdlDynamicTableSpecial<T>::setNormalized(const float& value, const int& j, const int& i, const int& d)
843  {
844  if(!isNormalized())
845  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(HdlDynamicTableSpecial<T>::denormalize(value));
846  else
847  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = static_cast<T>(value);
848  }
849 
850  template<typename T>
851  void* HdlDynamicTableSpecial<T>::get(const int& j, const int& i, const int& d) const
852  {
853  return reinterpret_cast<void*>(data + getOffset(j, i, d));
854  }
855 
856  template<typename T>
857  void HdlDynamicTableSpecial<T>::set(void* value, const int& j, const int& i, const int& d) const
858  {
859  (*reinterpret_cast<T*>(data + getOffset(j, i, d))) = (*reinterpret_cast<T*>(value));
860  }
861 
862  template<typename T>
863  float HdlDynamicTableSpecial<T>::readf(size_t offset) const
864  {
865  if(!isNormalized())
866  return static_cast<float>(*reinterpret_cast<const T*>(data+offset));
867  else
868  return HdlDynamicTableSpecial<float>::denormalize(*reinterpret_cast<const T*>(data+offset));
869  }
870 
871  template<typename T>
872  void HdlDynamicTableSpecial<T>::writef(const float& value, size_t offset)
873  {
874  if(!isNormalized())
875  (*reinterpret_cast<T*>(data+offset)) = static_cast<T>(value);
876  else
877  (*reinterpret_cast<T*>(data+offset)) = HdlDynamicTableSpecial<float>::normalize(value);
878  }
879 
880  template<typename T>
881  double HdlDynamicTableSpecial<T>::readd(size_t offset) const
882  {
883  if(!isNormalized())
884  return static_cast<double>(*reinterpret_cast<const T*>(data+offset));
885  else
886  return HdlDynamicTableSpecial<double>::denormalize(*reinterpret_cast<const T*>(data+offset));
887  }
888 
889  template<typename T>
890  void HdlDynamicTableSpecial<T>::writed(const double& value, size_t offset)
891  {
892  if(!isNormalized())
893  (*reinterpret_cast<T*>(data+offset)) = static_cast<T>(value);
894  else
895  (*reinterpret_cast<T*>(data+offset)) = HdlDynamicTableSpecial<double>::normalize(value);
896  }
897 
898  template<typename T>
899  long long HdlDynamicTableSpecial<T>::readl(size_t offset) const
900  {
901  if(!isNormalized())
902  return static_cast<long long>(*reinterpret_cast<const T*>(data+offset));
903  else
904  return HdlDynamicTableSpecial<long long>::denormalize(*reinterpret_cast<const T*>(data+offset));
905  }
906 
907  template<typename T>
908  void HdlDynamicTableSpecial<T>::writel(const long long& value, size_t offset)
909  {
910  if(!isNormalized())
911  (*reinterpret_cast<T*>(data+offset)) = static_cast<T>(value);
912  else
913  (*reinterpret_cast<T*>(data+offset)) = HdlDynamicTableSpecial<long long>::normalize(value);
914  }
915 
916  template<typename T>
917  int HdlDynamicTableSpecial<T>::readi(size_t offset) const
918  {
919  if(!isNormalized())
920  return static_cast<int>(*reinterpret_cast<const T*>(data+offset));
921  else
922  return HdlDynamicTableSpecial<int>::denormalize(*reinterpret_cast<const T*>(data+offset));
923  }
924 
925  template<typename T>
926  void HdlDynamicTableSpecial<T>::writei(const int& value, size_t offset)
927  {
928  if(!isNormalized())
929  (*reinterpret_cast<T*>(data+offset)) = static_cast<T>(value);
930  else
931  (*reinterpret_cast<T*>(data+offset)) = HdlDynamicTableSpecial<int>::normalize(value);
932  }
933 
934  template<typename T>
935  unsigned char HdlDynamicTableSpecial<T>::readb(size_t offset) const
936  {
937  if(!isNormalized())
938  return static_cast<unsigned char>(*reinterpret_cast<const T*>(data+offset));
939  else
940  return HdlDynamicTableSpecial<unsigned char>::denormalize(*reinterpret_cast<const T*>(data+offset));
941  }
942 
943  template<typename T>
944  void HdlDynamicTableSpecial<T>::writeb(const unsigned char& value, size_t offset)
945  {
946  if(!isNormalized())
947  (*reinterpret_cast<T*>(data+offset)) = static_cast<T>(value);
948  else
949  (*reinterpret_cast<T*>(data+offset)) = HdlDynamicTableSpecial<unsigned char>::normalize(value);
950  }
951 
952  template<typename T>
953  float HdlDynamicTableSpecial<T>::readNormalized(size_t offset) const
954  {
955  if(!isNormalized())
956  return HdlDynamicTableSpecial<T>::normalize(*reinterpret_cast<const T*>(data+offset));
957  else
958  return static_cast<float>(*reinterpret_cast<const T*>(data+offset));
959  }
960 
961  template<typename T>
962  void HdlDynamicTableSpecial<T>::writeNormalized(const float& value, size_t offset)
963  {
964  if(!isNormalized())
965  (*reinterpret_cast<T*>(data+offset)) = HdlDynamicTableSpecial<T>::denormalize(value);
966  else
967  (*reinterpret_cast<T*>(data+offset)) = static_cast<T>(value);
968  }
969 
970  template<typename T>
971  void HdlDynamicTableSpecial<T>::write(const void* value, size_t offset)
972  {
973  (*reinterpret_cast<T*>(data+offset)) = (*reinterpret_cast<const T*>(value));
974  }
975 
976  template<typename T>
977  const void* HdlDynamicTableSpecial<T>::getPtr(void) const
978  {
979  return reinterpret_cast<void*>(data);
980  }
981 
982  template<typename T>
983  void* HdlDynamicTableSpecial<T>::getPtr(void)
984  {
985  return reinterpret_cast<void*>(data);
986  }
987 
988  template<typename T>
989  const void* HdlDynamicTableSpecial<T>::getRowPtr(int i) const
990  {
991  return reinterpret_cast<void*>(data + i *getRowSize());
992  }
993 
994  template<typename T>
995  void* HdlDynamicTableSpecial<T>::getRowPtr(int i)
996  {
997  return reinterpret_cast<void*>(data + i *getRowSize());
998  }
999 
1000  template<typename T>
1001  const HdlDynamicTable& HdlDynamicTableSpecial<T>::operator=(const HdlDynamicTable& cpy)
1002  {
1003  if(cpy.getGLType()!=getGLType())
1004  throw Exception("HdlDynamicTableSpecial<T>::operator= - Data types do not match (target : \"" + getGLEnumName(cpy.getGLType()) + "\"; source : \"" + getGLEnumName(cpy.getGLType()) + "\").", __FILE__, __LINE__, Exception::CoreException);
1005  if(cpy.getNumRows()!=getNumRows() || cpy.getNumColumns()!=getNumColumns() || cpy.getNumSlices()!=getNumSlices())
1006  throw Exception("HdlDynamicTableSpecial<T>::operator= - Data format does not match.", __FILE__, __LINE__, Exception::CoreException);
1007 
1008  if(cpy.getAlignment()==getAlignment())
1009  std::memcpy(data, cpy.getPtr(), getSize());
1010  else
1011  {
1012  // Scan every row :
1013  for(int i=0; i<cpy.getNumRows(); i++)
1014  std::memcpy(getRowPtr(i), cpy.getRowPtr(i), std::min(getRowSize(), cpy.getRowSize()));
1015  }
1016 
1017  return (*this);
1018  }
1019 
1020  template<typename T>
1021  float HdlDynamicTableSpecial<T>::normalize(const T& t)
1022  {
1023  return (static_cast<float>(t) - static_cast<float>(std::numeric_limits<T>::min())) / (static_cast<float>(std::numeric_limits<T>::max()) - static_cast<float>(std::numeric_limits<T>::min()));
1024  }
1025 
1026  template<typename T>
1027  T HdlDynamicTableSpecial<T>::denormalize(const float& t)
1028  {
1029  return static_cast<T>(t * (static_cast<float>(std::numeric_limits<T>::max()) - static_cast<float>(std::numeric_limits<T>::min())) + static_cast<float>(std::numeric_limits<T>::min()));
1030  }
1031  }
1032  }
1033 
1034 #endif
1035 
LibTools.hpp
Specific defines for the API structure.
Glip
Definition: Component.hpp:32
Glip::CoreGL::HdlDynamicTable
Dynamic table allocator for GL types (run-time resolution of type).
Definition: HdlDynamicData.hpp:299
Glip::CoreGL::HdlDynamicData
Dynamic allocator for GL types (run-time resolution of type).
Definition: HdlDynamicData.hpp:65
Glip::CoreGL::HdlDynamicData::getNumElements
int getNumElements(void) const
Get the number of elements of the matrix (rows times columns).
Definition: HdlDynamicData.cpp:176
Exception.hpp
Exception class.
Glip::CoreGL::HdlDynamicTable::getSize
size_t getSize(void) const
Get the size of whole table, in bytes.
Definition: HdlDynamicData.cpp:477
OglInclude.hpp
OpenGL includes and tools.
Glip::Exception::CoreException
From a core library component.
Definition: Exception.hpp:49
Generated on Sun Aug 30 2015 21:47:07 for GLIP-Lib by   doxygen 1.8.8