PolyVox  0.3.0-dev
Open source voxel management library
BaseVolumeSampler.inl
Go to the documentation of this file.
1 /*******************************************************************************
2 Copyright (c) 2005-2009 David Williams
3 
4 This software is provided 'as-is', without any express or implied
5 warranty. In no event will the authors be held liable for any damages
6 arising from the use of this software.
7 
8 Permission is granted to anyone to use this software for any purpose,
9 including commercial applications, and to alter it and redistribute it
10 freely, subject to the following restrictions:
11 
12  1. The origin of this software must not be misrepresented; you must not
13  claim that you wrote the original software. If you use this software
14  in a product, an acknowledgment in the product documentation would be
15  appreciated but is not required.
16 
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19 
20  3. This notice may not be removed or altered from any source
21  distribution.
22 *******************************************************************************/
23 
24 #include "PolyVoxCore/Impl/Utility.h"
25 
26 namespace PolyVox
27 {
28  template <typename VoxelType>
29  template <typename DerivedVolumeType>
30  BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::Sampler(DerivedVolumeType* volume)
31  :mVolume(volume)
32  ,mXPosInVolume(0)
33  ,mYPosInVolume(0)
34  ,mZPosInVolume(0)
35  ,m_eWrapMode(WrapModes::Border)
36  ,m_tBorder()
37  ,m_bIsCurrentPositionValidInX(false)
38  ,m_bIsCurrentPositionValidInY(false)
39  ,m_bIsCurrentPositionValidInZ(false)
40  {
41  }
42 
43  template <typename VoxelType>
44  template <typename DerivedVolumeType>
45  BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::~Sampler()
46  {
47  }
48 
49  template <typename VoxelType>
50  template <typename DerivedVolumeType>
51  Vector3DInt32 BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getPosition(void) const
52  {
53  return Vector3DInt32(mXPosInVolume, mYPosInVolume, mZPosInVolume);
54  }
55 
56  template <typename VoxelType>
57  template <typename DerivedVolumeType>
58  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getVoxel(void) const
59  {
60  return mVolume->getVoxelAt(mXPosInVolume, mYPosInVolume, mZPosInVolume);
61  }
62 
63  template <typename VoxelType>
64  template <typename DerivedVolumeType>
65  bool inline BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::isCurrentPositionValid(void) const
66  {
67  return m_bIsCurrentPositionValidInX && m_bIsCurrentPositionValidInY && m_bIsCurrentPositionValidInZ;
68  }
69 
70  template <typename VoxelType>
71  template <typename DerivedVolumeType>
72  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setPosition(const Vector3DInt32& v3dNewPos)
73  {
74  setPosition(v3dNewPos.getX(), v3dNewPos.getY(), v3dNewPos.getZ());
75  }
76 
77  template <typename VoxelType>
78  template <typename DerivedVolumeType>
79  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setPosition(int32_t xPos, int32_t yPos, int32_t zPos)
80  {
81  mXPosInVolume = xPos;
82  mYPosInVolume = yPos;
83  mZPosInVolume = zPos;
84 
85  m_bIsCurrentPositionValidInX = mVolume->getEnclosingRegion().containsPointInX(xPos);
86  m_bIsCurrentPositionValidInY = mVolume->getEnclosingRegion().containsPointInY(yPos);
87  m_bIsCurrentPositionValidInZ = mVolume->getEnclosingRegion().containsPointInZ(zPos);
88  }
89 
90  template <typename VoxelType>
91  template <typename DerivedVolumeType>
92  bool BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setVoxel(VoxelType tValue)
93  {
94  return mVolume->setVoxelAt(mXPosInVolume, mYPosInVolume, mZPosInVolume, tValue);
95  }
96 
97  template <typename VoxelType>
98  template <typename DerivedVolumeType>
99  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setWrapMode(WrapMode eWrapMode, VoxelType tBorder)
100  {
101  m_eWrapMode = eWrapMode;
102  m_tBorder = tBorder;
103  }
104 
105  template <typename VoxelType>
106  template <typename DerivedVolumeType>
107  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::movePositiveX(void)
108  {
109  mXPosInVolume++;
110  m_bIsCurrentPositionValidInX = mVolume->getEnclosingRegion().containsPointInX(mXPosInVolume);
111  }
112 
113  template <typename VoxelType>
114  template <typename DerivedVolumeType>
115  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::movePositiveY(void)
116  {
117  mYPosInVolume++;
118  m_bIsCurrentPositionValidInY = mVolume->getEnclosingRegion().containsPointInY(mYPosInVolume);
119  }
120 
121  template <typename VoxelType>
122  template <typename DerivedVolumeType>
123  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::movePositiveZ(void)
124  {
125  mZPosInVolume++;
126  m_bIsCurrentPositionValidInZ = mVolume->getEnclosingRegion().containsPointInZ(mZPosInVolume);
127  }
128 
129  template <typename VoxelType>
130  template <typename DerivedVolumeType>
131  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::moveNegativeX(void)
132  {
133  mXPosInVolume--;
134  m_bIsCurrentPositionValidInX = mVolume->getEnclosingRegion().containsPointInX(mXPosInVolume);
135  }
136 
137  template <typename VoxelType>
138  template <typename DerivedVolumeType>
139  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::moveNegativeY(void)
140  {
141  mYPosInVolume--;
142  m_bIsCurrentPositionValidInY = mVolume->getEnclosingRegion().containsPointInY(mYPosInVolume);
143  }
144 
145  template <typename VoxelType>
146  template <typename DerivedVolumeType>
147  void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::moveNegativeZ(void)
148  {
149  mZPosInVolume--;
150  m_bIsCurrentPositionValidInZ = mVolume->getEnclosingRegion().containsPointInZ(mZPosInVolume);
151  }
152 
153  template <typename VoxelType>
154  template <typename DerivedVolumeType>
155  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1ny1nz(void) const
156  {
157  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume - 1, mZPosInVolume - 1);
158  }
159 
160  template <typename VoxelType>
161  template <typename DerivedVolumeType>
162  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1ny0pz(void) const
163  {
164  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume - 1, mZPosInVolume );
165  }
166 
167  template <typename VoxelType>
168  template <typename DerivedVolumeType>
169  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1ny1pz(void) const
170  {
171  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume - 1, mZPosInVolume + 1);
172  }
173 
174  template <typename VoxelType>
175  template <typename DerivedVolumeType>
176  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx0py1nz(void) const
177  {
178  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume , mZPosInVolume - 1);
179  }
180 
181  template <typename VoxelType>
182  template <typename DerivedVolumeType>
183  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx0py0pz(void) const
184  {
185  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume , mZPosInVolume );
186  }
187 
188  template <typename VoxelType>
189  template <typename DerivedVolumeType>
190  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx0py1pz(void) const
191  {
192  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume , mZPosInVolume + 1);
193  }
194 
195  template <typename VoxelType>
196  template <typename DerivedVolumeType>
197  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1py1nz(void) const
198  {
199  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume + 1, mZPosInVolume - 1);
200  }
201 
202  template <typename VoxelType>
203  template <typename DerivedVolumeType>
204  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1py0pz(void) const
205  {
206  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume + 1, mZPosInVolume );
207  }
208 
209  template <typename VoxelType>
210  template <typename DerivedVolumeType>
211  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1py1pz(void) const
212  {
213  return getVoxelAt(mXPosInVolume - 1, mYPosInVolume + 1, mZPosInVolume + 1);
214  }
215 
217 
218  template <typename VoxelType>
219  template <typename DerivedVolumeType>
220  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1ny1nz(void) const
221  {
222  return getVoxelAt(mXPosInVolume , mYPosInVolume - 1, mZPosInVolume - 1);
223  }
224 
225  template <typename VoxelType>
226  template <typename DerivedVolumeType>
227  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1ny0pz(void) const
228  {
229  return getVoxelAt(mXPosInVolume , mYPosInVolume - 1, mZPosInVolume );
230  }
231 
232  template <typename VoxelType>
233  template <typename DerivedVolumeType>
234  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1ny1pz(void) const
235  {
236  return getVoxelAt(mXPosInVolume , mYPosInVolume - 1, mZPosInVolume + 1);
237  }
238 
239  template <typename VoxelType>
240  template <typename DerivedVolumeType>
241  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px0py1nz(void) const
242  {
243  return getVoxelAt(mXPosInVolume , mYPosInVolume , mZPosInVolume - 1);
244  }
245 
246  template <typename VoxelType>
247  template <typename DerivedVolumeType>
248  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px0py0pz(void) const
249  {
250  return getVoxelAt(mXPosInVolume , mYPosInVolume , mZPosInVolume );
251  }
252 
253  template <typename VoxelType>
254  template <typename DerivedVolumeType>
255  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px0py1pz(void) const
256  {
257  return getVoxelAt(mXPosInVolume , mYPosInVolume , mZPosInVolume + 1);
258  }
259 
260  template <typename VoxelType>
261  template <typename DerivedVolumeType>
262  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1py1nz(void) const
263  {
264  return getVoxelAt(mXPosInVolume , mYPosInVolume + 1, mZPosInVolume - 1);
265  }
266 
267  template <typename VoxelType>
268  template <typename DerivedVolumeType>
269  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1py0pz(void) const
270  {
271  return getVoxelAt(mXPosInVolume , mYPosInVolume + 1, mZPosInVolume );
272  }
273 
274  template <typename VoxelType>
275  template <typename DerivedVolumeType>
276  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1py1pz(void) const
277  {
278  return getVoxelAt(mXPosInVolume , mYPosInVolume + 1, mZPosInVolume + 1);
279  }
280 
282 
283  template <typename VoxelType>
284  template <typename DerivedVolumeType>
285  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1ny1nz(void) const
286  {
287  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume - 1, mZPosInVolume - 1);
288  }
289 
290  template <typename VoxelType>
291  template <typename DerivedVolumeType>
292  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1ny0pz(void) const
293  {
294  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume - 1, mZPosInVolume );
295  }
296 
297  template <typename VoxelType>
298  template <typename DerivedVolumeType>
299  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1ny1pz(void) const
300  {
301  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume - 1, mZPosInVolume + 1);
302  }
303 
304  template <typename VoxelType>
305  template <typename DerivedVolumeType>
306  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px0py1nz(void) const
307  {
308  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume , mZPosInVolume - 1);
309  }
310 
311  template <typename VoxelType>
312  template <typename DerivedVolumeType>
313  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px0py0pz(void) const
314  {
315  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume , mZPosInVolume );
316  }
317 
318  template <typename VoxelType>
319  template <typename DerivedVolumeType>
320  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px0py1pz(void) const
321  {
322  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume , mZPosInVolume + 1);
323  }
324 
325  template <typename VoxelType>
326  template <typename DerivedVolumeType>
327  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1py1nz(void) const
328  {
329  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume + 1, mZPosInVolume - 1);
330  }
331 
332  template <typename VoxelType>
333  template <typename DerivedVolumeType>
334  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1py0pz(void) const
335  {
336  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume + 1, mZPosInVolume );
337  }
338 
339  template <typename VoxelType>
340  template <typename DerivedVolumeType>
341  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1py1pz(void) const
342  {
343  return getVoxelAt(mXPosInVolume + 1, mYPosInVolume + 1, mZPosInVolume + 1);
344  }
345 
346  template <typename VoxelType>
347  template <typename DerivedVolumeType>
348  VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getVoxelAt(int32_t uXPos, int32_t uYPos, int32_t uZPos) const
349  {
350  if(mVolume->getEnclosingRegion().containsPoint(uXPos, uYPos, uZPos))
351  {
352  return mVolume->getVoxelAt(uXPos, uYPos, uZPos);
353  }
354  else
355  {
356  switch(m_eWrapMode)
357  {
358  case WrapModes::Clamp:
359  {
360  const Vector3DInt32& lowerCorner = mVolume->m_regValidRegion.getLowerCorner();
361  const Vector3DInt32& upperCorner = mVolume->m_regValidRegion.getUpperCorner();
362 
363  int32_t iClampedX = clamp(uXPos, lowerCorner.getX(), upperCorner.getX());
364  int32_t iClampedY = clamp(uYPos, lowerCorner.getY(), upperCorner.getY());
365  int32_t iClampedZ = clamp(uZPos, lowerCorner.getZ(), upperCorner.getZ());
366 
367  return mVolume->getVoxelAt(iClampedX, iClampedY, iClampedZ);
368  //No need to break as we've returned
369  }
370  case WrapModes::Border:
371  {
372  return m_tBorder;
373  //No need to break as we've returned
374  }
375  default:
376  {
377  //Should never happen
378  POLYVOX_ASSERT(false, "Invalid case.");
379  return VoxelType();
380  }
381  }
382  }
383  }
384 }
Generated by   doxygen 1.8.2