00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00034
00035
00036 #ifndef OPENIMAGEIO_VARYINGREF_H
00037 #define OPENIMAGEIO_VARYINGREF_H
00038
00039 #ifdef OPENIMAGEIO_NAMESPACE
00040 namespace OPENIMAGEIO_NAMESPACE {
00041 #endif
00042
00043
00129
00130 template<class T>
00131 class VaryingRef {
00132 public:
00133 VaryingRef () { init (0, 0); }
00134
00139 VaryingRef (void *ptr, int step=0) { init ((T *)ptr,step); }
00140
00143 VaryingRef (T &ptr) { init (&ptr, 0); }
00144
00149 void init (T *ptr, int step=0) {
00150 m_ptr = ptr;
00151 m_step = step;
00152 }
00153
00156 const VaryingRef & operator= (T &ptr) { init (&ptr); return *this; }
00157
00160 bool is_null () const { return (m_ptr == 0); }
00161
00164 operator void*() const { return m_ptr; }
00165
00168 bool is_varying () const { return (m_step != 0); }
00169
00172 bool is_uniform () const { return (m_step == 0); }
00173
00178 VaryingRef & operator++ () {
00179 *((char **)&m_ptr) += m_step;
00180 return *this;
00181 }
00186 void operator++ (int) {
00187
00188 *((char **)&m_ptr) += m_step;
00189
00190 }
00191
00194 T & operator* () const { return *m_ptr; }
00195
00199 T & operator[] (int i) const { return *(T *) ((char *)m_ptr + i*m_step); }
00200
00203 T * ptr () const { return m_ptr; }
00204
00207 int step () const { return m_step; }
00208
00209 private:
00210 T *m_ptr;
00211 int m_step;
00212 };
00213
00214
00215
00218 template<class T>
00219 VaryingRef<T> Varying (T *x) { return VaryingRef<T> (x, sizeof(T)); }
00220
00223 template<class T>
00224 VaryingRef<T> Uniform (T *x) { return VaryingRef<T> (x, 0); }
00225
00228 template<class T>
00229 VaryingRef<T> Uniform (T &x) { return VaryingRef<T> (&x, 0); }
00230
00231
00232 #ifdef OPENIMAGEIO_NAMESPACE
00233 };
00234 using namespace OPENIMAGEIO_NAMESPACE;
00235 #endif
00236
00237 #endif // OPENIMAGEIO_VARYINGREF_H