PolyVox  0.3.0-dev
Open source voxel management library
LargeVolumeSampler.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 #define CAN_GO_NEG_X(val) ((val > this->mVolume->getEnclosingRegion().getLowerX()) && (val % this->mVolume->m_uBlockSideLength != 0))
25 #define CAN_GO_POS_X(val) ((val < this->mVolume->getEnclosingRegion().getUpperX()) && ((val + 1) % this->mVolume->m_uBlockSideLength != 0))
26 #define CAN_GO_NEG_Y(val) ((val > this->mVolume->getEnclosingRegion().getLowerY()) && (val % this->mVolume->m_uBlockSideLength != 0))
27 #define CAN_GO_POS_Y(val) ((val < this->mVolume->getEnclosingRegion().getUpperY()) && ((val + 1) % this->mVolume->m_uBlockSideLength != 0))
28 #define CAN_GO_NEG_Z(val) ((val > this->mVolume->getEnclosingRegion().getLowerZ()) && (val % this->mVolume->m_uBlockSideLength != 0))
29 #define CAN_GO_POS_Z(val) ((val < this->mVolume->getEnclosingRegion().getUpperZ()) && ((val + 1) % this->mVolume->m_uBlockSideLength != 0))
30 
31 namespace PolyVox
32 {
33  template <typename VoxelType>
34  LargeVolume<VoxelType>::Sampler::Sampler(LargeVolume<VoxelType>* volume)
35  :BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >(volume)
36  {
37  }
38 
39  template <typename VoxelType>
40  LargeVolume<VoxelType>::Sampler::~Sampler()
41  {
42  }
43 
44  template <typename VoxelType>
45  VoxelType LargeVolume<VoxelType>::Sampler::getSubSampledVoxel(uint8_t uLevel) const
46  {
47  if(uLevel == 0)
48  {
49  return getVoxel();
50  }
51  else if(uLevel == 1)
52  {
53  VoxelType tValue = getVoxel();
54  tValue = (std::min)(tValue, peekVoxel1px0py0pz());
55  tValue = (std::min)(tValue, peekVoxel0px1py0pz());
56  tValue = (std::min)(tValue, peekVoxel1px1py0pz());
57  tValue = (std::min)(tValue, peekVoxel0px0py1pz());
58  tValue = (std::min)(tValue, peekVoxel1px0py1pz());
59  tValue = (std::min)(tValue, peekVoxel0px1py1pz());
60  tValue = (std::min)(tValue, peekVoxel1px1py1pz());
61  return tValue;
62  }
63  else
64  {
65  const uint8_t uSize = 1 << uLevel;
66 
67  VoxelType tValue = (std::numeric_limits<VoxelType>::max)();
68  for(uint8_t z = 0; z < uSize; ++z)
69  {
70  for(uint8_t y = 0; y < uSize; ++y)
71  {
72  for(uint8_t x = 0; x < uSize; ++x)
73  {
74  tValue = (std::min)(tValue, this->mVolume->getVoxelAt(this->mXPosInVolume + x, this->mYPosInVolume + y, this->mZPosInVolume + z));
75  }
76  }
77  }
78  return tValue;
79  }
80  }
81 
82  template <typename VoxelType>
83  VoxelType LargeVolume<VoxelType>::Sampler::getVoxel(void) const
84  {
85  if(this->isCurrentPositionValid())
86  {
87  return *mCurrentVoxel;
88  }
89  else
90  {
91  return getVoxelAt(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
92  }
93  }
94 
95  template <typename VoxelType>
96  void LargeVolume<VoxelType>::Sampler::setPosition(const Vector3DInt32& v3dNewPos)
97  {
98  setPosition(v3dNewPos.getX(), v3dNewPos.getY(), v3dNewPos.getZ());
99  }
100 
101  template <typename VoxelType>
102  void LargeVolume<VoxelType>::Sampler::setPosition(int32_t xPos, int32_t yPos, int32_t zPos)
103  {
104  // Base version updates position and validity flags.
105  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::setPosition(xPos, yPos, zPos);
106 
107  // Then we update the voxel pointer
108  if(this->isCurrentPositionValid())
109  {
110  const int32_t uXBlock = this->mXPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
111  const int32_t uYBlock = this->mYPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
112  const int32_t uZBlock = this->mZPosInVolume >> this->mVolume->m_uBlockSideLengthPower;
113 
114  const uint16_t uXPosInBlock = static_cast<uint16_t>(this->mXPosInVolume - (uXBlock << this->mVolume->m_uBlockSideLengthPower));
115  const uint16_t uYPosInBlock = static_cast<uint16_t>(this->mYPosInVolume - (uYBlock << this->mVolume->m_uBlockSideLengthPower));
116  const uint16_t uZPosInBlock = static_cast<uint16_t>(this->mZPosInVolume - (uZBlock << this->mVolume->m_uBlockSideLengthPower));
117 
118  const uint32_t uVoxelIndexInBlock = uXPosInBlock +
119  uYPosInBlock * this->mVolume->m_uBlockSideLength +
120  uZPosInBlock * this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
121 
122  Block<VoxelType>* pUncompressedCurrentBlock = this->mVolume->getUncompressedBlock(uXBlock, uYBlock, uZBlock);
123 
124  mCurrentVoxel = pUncompressedCurrentBlock->m_tUncompressedData + uVoxelIndexInBlock;
125  }
126  else
127  {
128  mCurrentVoxel = 0;
129  }
130  }
131 
132  template <typename VoxelType>
133  bool LargeVolume<VoxelType>::Sampler::setVoxel(VoxelType tValue)
134  {
135  /*if(m_bIsCurrentPositionValidInX && m_bIsCurrentPositionValidInY && m_bIsCurrentPositionValidInZ)
136  {
137  *mCurrentVoxel = tValue;
138  return true;
139  }
140  else
141  {
142  return false;
143  }*/
144 
145  //Need to think what effect this has on any existing iterators.
146  POLYVOX_ASSERT(false, "This function cnnot be used on LargeVolume samplers.");
147  return false;
148  }
149 
150  template <typename VoxelType>
151  void LargeVolume<VoxelType>::Sampler::movePositiveX(void)
152  {
153  // We'll need this in a moment...
154  bool bIsOldPositionValid = this->isCurrentPositionValid();
155 
156  // Base version updates position and validity flags.
157  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::movePositiveX();
158 
159  // Then we update the voxel pointer
160  if((this->isCurrentPositionValid()) && bIsOldPositionValid && ((this->mXPosInVolume) % this->mVolume->m_uBlockSideLength != 0))
161  {
162  //No need to compute new block.
163  ++mCurrentVoxel;
164  }
165  else
166  {
167  //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
168  setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
169  }
170  }
171 
172  template <typename VoxelType>
173  void LargeVolume<VoxelType>::Sampler::movePositiveY(void)
174  {
175  // We'll need this in a moment...
176  bool bIsOldPositionValid = this->isCurrentPositionValid();
177 
178  // Base version updates position and validity flags.
179  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::movePositiveY();
180 
181  // Then we update the voxel pointer
182  if((this->isCurrentPositionValid()) && bIsOldPositionValid && ((this->mYPosInVolume) % this->mVolume->m_uBlockSideLength != 0))
183  {
184  //No need to compute new block.
185  mCurrentVoxel += this->mVolume->m_uBlockSideLength;
186  }
187  else
188  {
189  //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
190  setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
191  }
192  }
193 
194  template <typename VoxelType>
195  void LargeVolume<VoxelType>::Sampler::movePositiveZ(void)
196  {
197  // We'll need this in a moment...
198  bool bIsOldPositionValid = this->isCurrentPositionValid();
199 
200  // Base version updates position and validity flags.
201  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::movePositiveZ();
202 
203  // Then we update the voxel pointer
204  if((this->isCurrentPositionValid()) && bIsOldPositionValid && ((this->mZPosInVolume) % this->mVolume->m_uBlockSideLength != 0))
205  {
206  //No need to compute new block.
207  mCurrentVoxel += this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
208  }
209  else
210  {
211  //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
212  setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
213  }
214  }
215 
216  template <typename VoxelType>
217  void LargeVolume<VoxelType>::Sampler::moveNegativeX(void)
218  {
219  // We'll need this in a moment...
220  bool bIsOldPositionValid = this->isCurrentPositionValid();
221 
222  // Base version updates position and validity flags.
223  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::moveNegativeX();
224 
225  // Then we update the voxel pointer
226  if((this->isCurrentPositionValid()) && bIsOldPositionValid && ((this->mXPosInVolume + 1) % this->mVolume->m_uBlockSideLength != 0))
227  {
228  //No need to compute new block.
229  --mCurrentVoxel;
230  }
231  else
232  {
233  //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
234  setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
235  }
236  }
237 
238  template <typename VoxelType>
239  void LargeVolume<VoxelType>::Sampler::moveNegativeY(void)
240  {
241  // We'll need this in a moment...
242  bool bIsOldPositionValid = this->isCurrentPositionValid();
243 
244  // Base version updates position and validity flags.
245  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::moveNegativeY();
246 
247  // Then we update the voxel pointer
248  if((this->isCurrentPositionValid()) && bIsOldPositionValid && ((this->mYPosInVolume + 1) % this->mVolume->m_uBlockSideLength != 0))
249  {
250  //No need to compute new block.
251  mCurrentVoxel -= this->mVolume->m_uBlockSideLength;
252  }
253  else
254  {
255  //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
256  setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
257  }
258  }
259 
260  template <typename VoxelType>
261  void LargeVolume<VoxelType>::Sampler::moveNegativeZ(void)
262  {
263  // We'll need this in a moment...
264  bool bIsOldPositionValid = this->isCurrentPositionValid();
265 
266  // Base version updates position and validity flags.
267  BaseVolume<VoxelType>::template Sampler< LargeVolume<VoxelType> >::moveNegativeZ();
268 
269  // Then we update the voxel pointer
270  if((this->isCurrentPositionValid()) && bIsOldPositionValid && ((this->mZPosInVolume + 1) % this->mVolume->m_uBlockSideLength != 0))
271  {
272  //No need to compute new block.
273  mCurrentVoxel -= this->mVolume->m_uBlockSideLength * this->mVolume->m_uBlockSideLength;
274  }
275  else
276  {
277  //We've hit the block boundary. Just calling setPosition() is the easiest way to resolve this.
278  setPosition(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume);
279  }
280  }
281 
282  template <typename VoxelType>
283  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny1nz(void) const
284  {
285  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_NEG_Y(this->mYPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
286  {
287  return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
288  }
289  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
290  }
291 
292  template <typename VoxelType>
293  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny0pz(void) const
294  {
295  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_NEG_Y(this->mYPosInVolume) )
296  {
297  return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength);
298  }
299  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
300  }
301 
302  template <typename VoxelType>
303  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1ny1pz(void) const
304  {
305  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_NEG_Y(this->mYPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
306  {
307  return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
308  }
309  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume-1,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
310  }
311 
312  template <typename VoxelType>
313  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py1nz(void) const
314  {
315  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
316  {
317  return *(mCurrentVoxel - 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
318  }
319  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
320  }
321 
322  template <typename VoxelType>
323  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py0pz(void) const
324  {
325  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) )
326  {
327  return *(mCurrentVoxel - 1);
328  }
329  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
330  }
331 
332  template <typename VoxelType>
333  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx0py1pz(void) const
334  {
335  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
336  {
337  return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
338  }
339  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
340  }
341 
342  template <typename VoxelType>
343  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py1nz(void) const
344  {
345  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_POS_Y(this->mYPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
346  {
347  return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
348  }
349  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
350  }
351 
352  template <typename VoxelType>
353  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py0pz(void) const
354  {
355  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_POS_Y(this->mYPosInVolume) )
356  {
357  return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength);
358  }
359  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
360  }
361 
362  template <typename VoxelType>
363  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1nx1py1pz(void) const
364  {
365  if((this->isCurrentPositionValid()) && CAN_GO_NEG_X(this->mXPosInVolume) && CAN_GO_POS_Y(this->mYPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
366  {
367  return *(mCurrentVoxel - 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
368  }
369  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume-1,this->mYPosInVolume+1,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
370  }
371 
373 
374  template <typename VoxelType>
375  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny1nz(void) const
376  {
377  if((this->isCurrentPositionValid()) && CAN_GO_NEG_Y(this->mYPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
378  {
379  return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
380  }
381  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
382  }
383 
384  template <typename VoxelType>
385  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny0pz(void) const
386  {
387  if((this->isCurrentPositionValid()) && CAN_GO_NEG_Y(this->mYPosInVolume) )
388  {
389  return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength);
390  }
391  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
392  }
393 
394  template <typename VoxelType>
395  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1ny1pz(void) const
396  {
397  if((this->isCurrentPositionValid()) && CAN_GO_NEG_Y(this->mYPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
398  {
399  return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
400  }
401  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume-1,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
402  }
403 
404  template <typename VoxelType>
405  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py1nz(void) const
406  {
407  if((this->isCurrentPositionValid()) && CAN_GO_NEG_Z(this->mZPosInVolume) )
408  {
409  return *(mCurrentVoxel - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
410  }
411  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
412  }
413 
414  template <typename VoxelType>
415  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py0pz(void) const
416  {
417  if((this->isCurrentPositionValid()))
418  {
419  return *mCurrentVoxel;
420  }
421  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume, this->mYPosInVolume, this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
422  }
423 
424  template <typename VoxelType>
425  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px0py1pz(void) const
426  {
427  if((this->isCurrentPositionValid()) && CAN_GO_POS_Z(this->mZPosInVolume) )
428  {
429  return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
430  }
431  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
432  }
433 
434  template <typename VoxelType>
435  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py1nz(void) const
436  {
437  if((this->isCurrentPositionValid()) && CAN_GO_POS_Y(this->mYPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
438  {
439  return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
440  }
441  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
442  }
443 
444  template <typename VoxelType>
445  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py0pz(void) const
446  {
447  if((this->isCurrentPositionValid()) && CAN_GO_POS_Y(this->mYPosInVolume) )
448  {
449  return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength);
450  }
451  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
452  }
453 
454  template <typename VoxelType>
455  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel0px1py1pz(void) const
456  {
457  if((this->isCurrentPositionValid()) && CAN_GO_POS_Y(this->mYPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
458  {
459  return *(mCurrentVoxel + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
460  }
461  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume,this->mYPosInVolume+1,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
462  }
463 
465 
466  template <typename VoxelType>
467  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny1nz(void) const
468  {
469  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_NEG_Y(this->mYPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
470  {
471  return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
472  }
473  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
474  }
475 
476  template <typename VoxelType>
477  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny0pz(void) const
478  {
479  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_NEG_Y(this->mYPosInVolume) )
480  {
481  return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength);
482  }
483  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
484  }
485 
486  template <typename VoxelType>
487  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1ny1pz(void) const
488  {
489  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_NEG_Y(this->mYPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
490  {
491  return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
492  }
493  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume-1,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
494  }
495 
496  template <typename VoxelType>
497  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py1nz(void) const
498  {
499  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
500  {
501  return *(mCurrentVoxel + 1 - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
502  }
503  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
504  }
505 
506  template <typename VoxelType>
507  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py0pz(void) const
508  {
509  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) )
510  {
511  return *(mCurrentVoxel + 1);
512  }
513  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
514  }
515 
516  template <typename VoxelType>
517  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px0py1pz(void) const
518  {
519  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
520  {
521  return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
522  }
523  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
524  }
525 
526  template <typename VoxelType>
527  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py1nz(void) const
528  {
529  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_POS_Y(this->mYPosInVolume) && CAN_GO_NEG_Z(this->mZPosInVolume) )
530  {
531  return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength - this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
532  }
533  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume-1,this->m_eWrapMode, this->m_tBorder);
534  }
535 
536  template <typename VoxelType>
537  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py0pz(void) const
538  {
539  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_POS_Y(this->mYPosInVolume) )
540  {
541  return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength);
542  }
543  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume,this->m_eWrapMode, this->m_tBorder);
544  }
545 
546  template <typename VoxelType>
547  VoxelType LargeVolume<VoxelType>::Sampler::peekVoxel1px1py1pz(void) const
548  {
549  if((this->isCurrentPositionValid()) && CAN_GO_POS_X(this->mXPosInVolume) && CAN_GO_POS_Y(this->mYPosInVolume) && CAN_GO_POS_Z(this->mZPosInVolume) )
550  {
551  return *(mCurrentVoxel + 1 + this->mVolume->m_uBlockSideLength + this->mVolume->m_uBlockSideLength*this->mVolume->m_uBlockSideLength);
552  }
553  return this->mVolume->getVoxelWithWrapping(this->mXPosInVolume+1,this->mYPosInVolume+1,this->mZPosInVolume+1,this->m_eWrapMode, this->m_tBorder);
554  }
555 }
556 
557 #undef CAN_GO_NEG_X
558 #undef CAN_GO_POS_X
559 #undef CAN_GO_NEG_Y
560 #undef CAN_GO_POS_Y
561 #undef CAN_GO_NEG_Z
562 #undef CAN_GO_POS_Z
Generated by   doxygen 1.8.2