Code/Sandbox/Plugins/LodGeneratorPlugin/Util/Vector.h

   1 #pragma once
   2
   3 #include <vector>
   4 #include "Allocator.h"
   5
   6 namespace LODGenerator
   7 {
   8         template<class T>
   9         class CVector
  10         {
  11         public:
  12                 CVector()
  13                 {
  14                 }
  15
  16                 CVector(uint size)
  17                 {
  18                         m_List.resize(size);
  19                 }
  20
  21                 void resize(uint size)
  22                 {
  23                         m_List.resize(size);
  24                 }
  25
  26                 void resize(uint size,T v)
  27                 {
  28                         m_List.resize(size,v);
  29                 }
  30
  31                 CVector(const CVector& rhs)
  32                 {
  33                         m_List.clear();
  34                         for (int i=0;i<v.size();i++)
  35                         {
  36                                 m_List.push_back(v[i]);
  37                         }
  38                 }
  39
  40                 void allocate(unsigned int n)
  41                 {
  42                         clear();
  43                         m_List.reserve(n);
  44                 }
  45
  46                 void zero()
  47                 {
  48                         for (std::vector<T>::iterator iter = m_List.begin();iter != m_List.end();iter++)
  49                         {
  50                                 *iter = 0;
  51                         }
  52                 }
  53
  54                 void operator += (const CVector& v)
  55                 {
  56                         ASSERT(m_List.size() != v.size());
  57                         for (int i=0;i<m_List.size();i++)
  58                         {
  59                                 m_List[i] += v[i];
  60                         }
  61                 }
  62
  63                 void operator -= (const CVector& v)
  64                 {
  65                         ASSERT(m_List.size() != v.size());
  66                         for (int i=0;i<m_List.size();i++)
  67                         {
  68                                 m_List[i] -= v[i];
  69                         }
  70                 }
  71
  72                 void operator=(const CVector& v)
  73                 {
  74                         ASSERT(m_List.size() != v.size());
  75                         for (int i=0;i<m_List.size();i++)
  76                         {
  77                                 m_List[i] -= v[i];
  78                         }
  79                 }
  80
  81                 T& operator [] (int seat)
  82                 {
  83                         ASSERT(seat < m_List.size());
  84                         return m_List[seat];
  85                 }
  86
  87                 T operator [] (int seat) const
  88                 {
  89                         ASSERT(seat < m_List.size());
  90                         return m_List[seat];
  91                 }
  92
  93                 T& operator () (int seat)
  94                 {
  95                         ASSERT(seat < m_List.size());
  96                         return m_List[seat];
  97                 }
  98
  99                 T operator () (int seat) const
 100                 {
 101                         ASSERT(seat < m_List.size());
 102                         return m_List[seat];
 103                 }
 104
 105                 int size() const
 106                 {
 107                         return m_List.size();
 108                 }
 109
 110                 bool has_nan()
 111                 {
 112                         for(unsigned int i=0; i<m_List.size(); i++) {
 113                                 if(_isnan(m_List[i])) {
 114                                         return true ;
 115                                 }
 116                         }
 117                         return false ;
 118                 }
 119
 120                 T* data()
 121                 {
 122                         return m_List.data();
 123                 }
 124
 125                 const T* data() const
 126                 {
 127                         return m_List.data();
 128                 }
 129
 130                 void clear()
 131                 {
 132                         m_List.clear();
 133                 }
 134
 135         public:
 136                 std::vector<T> m_List;
 137         } ;
 138
 139         typedef CVector<double> CVectorD;
 140         typedef CVector<int> CVectorI;
 141 }
 142