PolyVox: PolyVoxCore/include/PolyVoxCore/BaseVolumeSampler.inl Source File

Go to the documentation of this file.
00001 /*******************************************************************************
00002 Copyright (c) 2005-2009 David Williams
00003 
00004 This software is provided 'as-is', without any express or implied
00005 warranty. In no event will the authors be held liable for any damages
00006 arising from the use of this software.
00007 
00008 Permission is granted to anyone to use this software for any purpose,
00009 including commercial applications, and to alter it and redistribute it
00010 freely, subject to the following restrictions:
00011 
00012     1. The origin of this software must not be misrepresented; you must not
00013     claim that you wrote the original software. If you use this software
00014     in a product, an acknowledgment in the product documentation would be
00015     appreciated but is not required.
00016 
00017     2. Altered source versions must be plainly marked as such, and must not be
00018     misrepresented as being the original software.
00019 
00020     3. This notice may not be removed or altered from any source
00021     distribution.   
00022 *******************************************************************************/
00023 
00024 namespace PolyVox
00025 {
00026     template <typename VoxelType>
00027     template <typename DerivedVolumeType>
00028     BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::Sampler(DerivedVolumeType* volume)
00029         :mVolume(volume)
00030         ,mXPosInVolume(0)
00031         ,mYPosInVolume(0)
00032         ,mZPosInVolume(0)
00033     {
00034     }
00035 
00036     template <typename VoxelType>
00037     template <typename DerivedVolumeType>
00038     BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::~Sampler()
00039     {
00040     }
00041 
00042     template <typename VoxelType>
00043     template <typename DerivedVolumeType>
00044     int32_t BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getPosX(void) const
00045     {
00046         return mXPosInVolume;
00047     }
00048 
00049     template <typename VoxelType>
00050     template <typename DerivedVolumeType>
00051     int32_t BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getPosY(void) const
00052     {
00053         return mYPosInVolume;
00054     }
00055 
00056     template <typename VoxelType>
00057     template <typename DerivedVolumeType>
00058     int32_t BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getPosZ(void) const
00059     {
00060         return mZPosInVolume;
00061     }
00062 
00063     template <typename VoxelType>
00064     template <typename DerivedVolumeType>
00065     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::getVoxel(void) const
00066     {
00067         return mVolume->getVoxelAt(mXPosInVolume, mYPosInVolume, mZPosInVolume);
00068     }
00069 
00070     template <typename VoxelType>
00071     template <typename DerivedVolumeType>
00072     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setPosition(const Vector3DInt32& v3dNewPos)
00073     {
00074         mXPosInVolume = v3dNewPos.getX();
00075         mYPosInVolume = v3dNewPos.getY();
00076         mZPosInVolume = v3dNewPos.getZ();
00077     }
00078 
00079     template <typename VoxelType>
00080     template <typename DerivedVolumeType>
00081     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setPosition(int32_t xPos, int32_t yPos, int32_t zPos)
00082     {
00083         mXPosInVolume = xPos;
00084         mYPosInVolume = yPos;
00085         mZPosInVolume = zPos;
00086     }
00087 
00088     template <typename VoxelType>
00089     template <typename DerivedVolumeType>
00090     bool BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::setVoxel(VoxelType tValue)
00091     {
00092         return mVolume->setVoxelAt(mXPosInVolume, mYPosInVolume, mZPosInVolume, tValue);
00093     }
00094 
00095     template <typename VoxelType>
00096     template <typename DerivedVolumeType>
00097     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::movePositiveX(void)
00098     {
00099         mXPosInVolume++;
00100     }
00101 
00102     template <typename VoxelType>
00103     template <typename DerivedVolumeType>
00104     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::movePositiveY(void)
00105     {
00106         mYPosInVolume++;
00107     }
00108 
00109     template <typename VoxelType>
00110     template <typename DerivedVolumeType>
00111     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::movePositiveZ(void)
00112     {
00113         mZPosInVolume++;
00114     }
00115 
00116     template <typename VoxelType>
00117     template <typename DerivedVolumeType>
00118     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::moveNegativeX(void)
00119     {
00120         mXPosInVolume--;
00121     }
00122 
00123     template <typename VoxelType>
00124     template <typename DerivedVolumeType>
00125     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::moveNegativeY(void)
00126     {
00127         mYPosInVolume--;
00128     }
00129 
00130     template <typename VoxelType>
00131     template <typename DerivedVolumeType>
00132     void BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::moveNegativeZ(void)
00133     {
00134         mZPosInVolume--;
00135     }
00136 
00137     template <typename VoxelType>
00138     template <typename DerivedVolumeType>
00139     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1ny1nz(void) const
00140     {
00141         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume - 1, mZPosInVolume - 1);
00142     }
00143 
00144     template <typename VoxelType>
00145     template <typename DerivedVolumeType>
00146     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1ny0pz(void) const
00147     {
00148         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume - 1, mZPosInVolume    );
00149     }
00150 
00151     template <typename VoxelType>
00152     template <typename DerivedVolumeType>
00153     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1ny1pz(void) const
00154     {
00155         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume - 1, mZPosInVolume + 1);
00156     }
00157 
00158     template <typename VoxelType>
00159     template <typename DerivedVolumeType>
00160     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx0py1nz(void) const
00161     {
00162         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume    , mZPosInVolume - 1);
00163     }
00164 
00165     template <typename VoxelType>
00166     template <typename DerivedVolumeType>
00167     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx0py0pz(void) const
00168     {
00169         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume    , mZPosInVolume    );
00170     }
00171 
00172     template <typename VoxelType>
00173     template <typename DerivedVolumeType>
00174     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx0py1pz(void) const
00175     {
00176         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume    , mZPosInVolume + 1);
00177     }
00178 
00179     template <typename VoxelType>
00180     template <typename DerivedVolumeType>
00181     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1py1nz(void) const
00182     {
00183         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume + 1, mZPosInVolume - 1);
00184     }
00185 
00186     template <typename VoxelType>
00187     template <typename DerivedVolumeType>
00188     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1py0pz(void) const
00189     {
00190         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume + 1, mZPosInVolume    );
00191     }
00192 
00193     template <typename VoxelType>
00194     template <typename DerivedVolumeType>
00195     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1nx1py1pz(void) const
00196     {
00197         return mVolume->getVoxelAt(mXPosInVolume - 1, mYPosInVolume + 1, mZPosInVolume + 1);
00198     }
00199 
00201 
00202     template <typename VoxelType>
00203     template <typename DerivedVolumeType>
00204     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1ny1nz(void) const
00205     {
00206         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume - 1, mZPosInVolume - 1);
00207     }
00208 
00209     template <typename VoxelType>
00210     template <typename DerivedVolumeType>
00211     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1ny0pz(void) const
00212     {
00213         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume - 1, mZPosInVolume    );
00214     }
00215 
00216     template <typename VoxelType>
00217     template <typename DerivedVolumeType>
00218     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1ny1pz(void) const
00219     {
00220         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume - 1, mZPosInVolume + 1);
00221     }
00222 
00223     template <typename VoxelType>
00224     template <typename DerivedVolumeType>
00225     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px0py1nz(void) const
00226     {
00227         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume    , mZPosInVolume - 1);
00228     }
00229 
00230     template <typename VoxelType>
00231     template <typename DerivedVolumeType>
00232     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px0py0pz(void) const
00233     {
00234         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume    , mZPosInVolume    );
00235     }
00236 
00237     template <typename VoxelType>
00238     template <typename DerivedVolumeType>
00239     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px0py1pz(void) const
00240     {
00241         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume    , mZPosInVolume + 1);
00242     }
00243 
00244     template <typename VoxelType>
00245     template <typename DerivedVolumeType>
00246     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1py1nz(void) const
00247     {
00248         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume + 1, mZPosInVolume - 1);
00249     }
00250 
00251     template <typename VoxelType>
00252     template <typename DerivedVolumeType>
00253     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1py0pz(void) const
00254     {
00255         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume + 1, mZPosInVolume    );
00256     }
00257 
00258     template <typename VoxelType>
00259     template <typename DerivedVolumeType>
00260     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel0px1py1pz(void) const
00261     {
00262         return mVolume->getVoxelAt(mXPosInVolume    , mYPosInVolume + 1, mZPosInVolume + 1);
00263     }
00264 
00266 
00267     template <typename VoxelType>
00268     template <typename DerivedVolumeType>
00269     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1ny1nz(void) const
00270     {
00271         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume - 1, mZPosInVolume - 1);
00272     }
00273 
00274     template <typename VoxelType>
00275     template <typename DerivedVolumeType>
00276     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1ny0pz(void) const
00277     {
00278         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume - 1, mZPosInVolume    );
00279     }
00280 
00281     template <typename VoxelType>
00282     template <typename DerivedVolumeType>
00283     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1ny1pz(void) const
00284     {
00285         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume - 1, mZPosInVolume + 1);
00286     }
00287 
00288     template <typename VoxelType>
00289     template <typename DerivedVolumeType>
00290     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px0py1nz(void) const
00291     {
00292         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume    , mZPosInVolume - 1);
00293     }
00294 
00295     template <typename VoxelType>
00296     template <typename DerivedVolumeType>
00297     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px0py0pz(void) const
00298     {
00299         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume    , mZPosInVolume    );
00300     }
00301 
00302     template <typename VoxelType>
00303     template <typename DerivedVolumeType>
00304     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px0py1pz(void) const
00305     {
00306         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume    , mZPosInVolume + 1);
00307     }
00308 
00309     template <typename VoxelType>
00310     template <typename DerivedVolumeType>
00311     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1py1nz(void) const
00312     {
00313         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume + 1, mZPosInVolume - 1);
00314     }
00315 
00316     template <typename VoxelType>
00317     template <typename DerivedVolumeType>
00318     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1py0pz(void) const
00319     {
00320         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume + 1, mZPosInVolume    );
00321     }
00322 
00323     template <typename VoxelType>
00324     template <typename DerivedVolumeType>
00325     VoxelType BaseVolume<VoxelType>::Sampler<DerivedVolumeType>::peekVoxel1px1py1pz(void) const
00326     {
00327         return mVolume->getVoxelAt(mXPosInVolume + 1, mYPosInVolume + 1, mZPosInVolume + 1);
00328     }
00329 }