From a502e84764577732e0e8874326d7f784f1a9dd5a Mon Sep 17 00:00:00 2001 From: David Williams Date: Sun, 9 Dec 2012 15:09:35 +0100 Subject: [PATCH] Updated comment style to match KDE/Kate (for Doxygen syntax highlighting). --- .../PolyVoxCore/include/PolyVoxCore/Region.h | 198 +++++------ library/PolyVoxCore/source/Region.cpp | 332 +++++++++--------- 2 files changed, 265 insertions(+), 265 deletions(-) diff --git a/library/PolyVoxCore/include/PolyVoxCore/Region.h b/library/PolyVoxCore/include/PolyVoxCore/Region.h index ae674a19..57419fd2 100644 --- a/library/PolyVoxCore/include/PolyVoxCore/Region.h +++ b/library/PolyVoxCore/include/PolyVoxCore/Region.h @@ -30,25 +30,25 @@ freely, subject to the following restrictions: namespace PolyVox { - /// Represents a part of a Volume. - //////////////////////////////////////////////////////////////////////////////// - /// Many operations in PolyVox are constrained to only part of a volume. For example, when running the surface extractors - /// it is unlikely that you will want to run it on the whole volume at once, as this will give a very large mesh which may - /// be too much to render. Instead you will probably want to run a surface extractor a number of times on different parts - /// of the volume, there by giving a number of meshes which can be culled and rendered seperately. - /// - /// The Region class is used to define these parts (regions) of the volume. Essentially it consists of an upper and lower - /// bound which specify the range of voxels positions considered to be part of the region. Note that these bounds are - /// inclusive. - /// - /// As well as the expected set of getters and setters, this class also provide utility functions for increasing and decresing - /// the size of the Region, shifting the Region in 3D space, testing whether it contains a given position, enlarging it so that - /// it does contain a given position, croppng it to another Region, and various other utility functions. - /// - /// \Note The dimensions of a region can be measured either in voxels or in cells. See the manual for more information - /// about these definitions. - /// - //////////////////////////////////////////////////////////////////////////////// + /** Represents a part of a Volume. + * + * Many operations in PolyVox are constrained to only part of a volume. For example, when running the surface extractors + * it is unlikely that you will want to run it on the whole volume at once, as this will give a very large mesh which may + * be too much to render. Instead you will probably want to run a surface extractor a number of times on different parts + * of the volume, there by giving a number of meshes which can be culled and rendered seperately. + * + * The Region class is used to define these parts (regions) of the volume. Essentially it consists of an upper and lower + * bound which specify the range of voxels positions considered to be part of the region. Note that these bounds are + * inclusive. + * + * As well as the expected set of getters and setters, this class also provide utility functions for increasing and decresing + * the size of the Region, shifting the Region in 3D space, testing whether it contains a given position, enlarging it so that + * it does contain a given position, croppng it to another Region, and various other utility functions. + * + * \Note The dimensions of a region can be measured either in voxels or in cells. See the manual for more information + * about these definitions. + * + */ #ifdef SWIG class Region #else @@ -199,193 +199,193 @@ namespace PolyVox // 'inline' keyword is used for the definition rather than the declaration. // See also http://www.parashift.com/c++-faq-lite/inline-functions.html - //////////////////////////////////////////////////////////////////////////////// - /// \return The 'x' position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The 'x' position of the lower corner. + */ inline int32_t Region::getLowerX(void) const { return m_iLowerX; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The 'y' position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The 'y' position of the lower corner. + */ inline int32_t Region::getLowerY(void) const { return m_iLowerY; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The 'z' position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The 'z' position of the lower corner. + */ inline int32_t Region::getLowerZ(void) const { return m_iLowerZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The 'x' position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The 'x' position of the upper corner. + */ inline int32_t Region::getUpperX(void) const { return m_iUpperX; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The 'y' position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The 'y' position of the upper corner. + */ inline int32_t Region::getUpperY(void) const { return m_iUpperY; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The 'z' position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The 'z' position of the upper corner. + */ inline int32_t Region::getUpperZ(void) const { return m_iUpperZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The position of the lower corner. + */ inline Vector3DInt32 Region::getLowerCorner(void) const { return Vector3DInt32(m_iLowerX, m_iLowerY, m_iLowerZ); } - //////////////////////////////////////////////////////////////////////////////// - /// \return The position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The position of the upper corner. + */ inline Vector3DInt32 Region::getUpperCorner(void) const { return Vector3DInt32(m_iUpperX, m_iUpperY, m_iUpperZ); } - //////////////////////////////////////////////////////////////////////////////// - /// \return The width of the region measured in voxels. - /// \sa getWidthInCells() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The width of the region measured in voxels. + * \sa getWidthInCells() + */ inline int32_t Region::getWidthInVoxels(void) const { return getWidthInCells() + 1; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The height of the region measured in voxels. - /// \sa getHeightInCells() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The height of the region measured in voxels. + * \sa getHeightInCells() + */ inline int32_t Region::getHeightInVoxels(void) const { return getHeightInCells() + 1; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The depth of the region measured in voxels. - /// \sa getDepthInCells() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The depth of the region measured in voxels. + * \sa getDepthInCells() + */ inline int32_t Region::getDepthInVoxels(void) const { return getDepthInCells() + 1; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The dimensions of the region measured in voxels. - /// \sa getDimensionsInCells() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The dimensions of the region measured in voxels. + * \sa getDimensionsInCells() + */ inline Vector3DInt32 Region::getDimensionsInVoxels(void) const { return getDimensionsInCells() + Vector3DInt32(1, 1, 1); } - //////////////////////////////////////////////////////////////////////////////// - /// \return The width of the region measured in cells. - /// \sa getWidthInVoxels() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The width of the region measured in cells. + * \sa getWidthInVoxels() + */ inline int32_t Region::getWidthInCells(void) const { return m_iUpperX - m_iLowerX; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The height of the region measured in cells. - /// \sa getHeightInVoxels() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The height of the region measured in cells. + * \sa getHeightInVoxels() + */ inline int32_t Region::getHeightInCells(void) const { return m_iUpperY - m_iLowerY; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The depth of the region measured in cells. - /// \sa getDepthInVoxels() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The depth of the region measured in cells. + * \sa getDepthInVoxels() + */ inline int32_t Region::getDepthInCells(void) const { return m_iUpperZ - m_iLowerZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \return The dimensions of the region measured in cells. - /// \sa getDimensionsInVoxels() - //////////////////////////////////////////////////////////////////////////////// + /** + * \return The dimensions of the region measured in cells. + * \sa getDimensionsInVoxels() + */ inline Vector3DInt32 Region::getDimensionsInCells(void) const { return Vector3DInt32(getWidthInCells(), getHeightInCells(), getDepthInCells()); } - //////////////////////////////////////////////////////////////////////////////// - /// \param iX The new 'x' position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iX The new 'x' position of the lower corner. + */ inline void Region::setLowerX(int32_t iX) { m_iLowerX = iX; } - //////////////////////////////////////////////////////////////////////////////// - /// \param iY The new 'y' position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iY The new 'y' position of the lower corner. + */ inline void Region::setLowerY(int32_t iY) { m_iLowerY = iY; } - //////////////////////////////////////////////////////////////////////////////// - /// \param iZ The new 'z' position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iZ The new 'z' position of the lower corner. + */ inline void Region::setLowerZ(int32_t iZ) { m_iLowerZ = iZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \param iX The new 'x' position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iX The new 'x' position of the upper corner. + */ inline void Region::setUpperX(int32_t iX) { m_iUpperX = iX; } - //////////////////////////////////////////////////////////////////////////////// - /// \param iY The new 'y' position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iY The new 'y' position of the upper corner. + */ inline void Region::setUpperY(int32_t iY) { m_iUpperY = iY; } - //////////////////////////////////////////////////////////////////////////////// - /// \param iZ The new 'z' position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iZ The new 'z' position of the upper corner. + */ inline void Region::setUpperZ(int32_t iZ) { m_iUpperZ = iZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \param v3dLowerCorner The new position of the lower corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param v3dLowerCorner The new position of the lower corner. + */ inline void Region::setLowerCorner(const Vector3DInt32& v3dLowerCorner) { m_iLowerX = v3dLowerCorner.getX(); @@ -393,9 +393,9 @@ namespace PolyVox m_iLowerZ = v3dLowerCorner.getZ(); } - //////////////////////////////////////////////////////////////////////////////// - /// \param v3dUpperCorner The new position of the upper corner. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param v3dUpperCorner The new position of the upper corner. + */ inline void Region::setUpperCorner(const Vector3DInt32& v3dUpperCorner) { m_iUpperX = v3dUpperCorner.getX(); diff --git a/library/PolyVoxCore/source/Region.cpp b/library/PolyVoxCore/source/Region.cpp index a3aafc6b..a693002f 100644 --- a/library/PolyVoxCore/source/Region.cpp +++ b/library/PolyVoxCore/source/Region.cpp @@ -28,30 +28,30 @@ freely, subject to the following restrictions: namespace PolyVox { - //////////////////////////////////////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////////// + /** + */ const Region Region::MaxRegion ( Vector3DInt32((std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)()), Vector3DInt32((std::numeric_limits::max)(), (std::numeric_limits::max)(), (std::numeric_limits::max)()) ); - //////////////////////////////////////////////////////////////////////////////// - /// This Region is not considered valid as defined by isValid(). It's main application - /// is to initialise a Region to this value and then() accumulate positions. The result - /// of this will be a Region which encompasses all positions specified. - //////////////////////////////////////////////////////////////////////////////// + /** + * This Region is not considered valid as defined by isValid(). It's main application + * is to initialise a Region to this value and then() accumulate positions. The result + * of this will be a Region which encompasses all positions specified. + */ const Region Region::InvertedRegion ( Vector3DInt32((std::numeric_limits::max)(), (std::numeric_limits::max)(), (std::numeric_limits::max)()), Vector3DInt32((std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)()) ); - //////////////////////////////////////////////////////////////////////////////// - /// \param iX The 'x' component of the position to accumulate. - /// \param iY The 'y' component of the position to accumulate. - /// \param iZ The 'z' component of the position to accumulate. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iX The 'x' component of the position to accumulate. + * \param iY The 'y' component of the position to accumulate. + * \param iZ The 'z' component of the position to accumulate. + */ void Region::accumulate(int32_t iX, int32_t iY, int32_t iZ) { m_iLowerX = ((std::min)(m_iLowerX, iX)); @@ -62,21 +62,21 @@ namespace PolyVox m_iUpperZ = ((std::max)(m_iUpperZ, iZ)); } - //////////////////////////////////////////////////////////////////////////////// - /// \param v3dPos The position to accumulate. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param v3dPos The position to accumulate. + */ void Region::accumulate(const Vector3DInt32& v3dPos) { accumulate(v3dPos.getX(), v3dPos.getY(), v3dPos.getZ()); } - //////////////////////////////////////////////////////////////////////////////// - /// Note that this is not the same as computing the union of two Regions (as the result of - /// such a union may not be a shape which can be exactly represented by a Region). Instead, - /// the result is simply big enough to contain both this Region and the one passed as a parameter. - /// \param reg The Region to accumulate. This must be valid as defined by the isValid() function. - /// \sa isValid() - //////////////////////////////////////////////////////////////////////////////// + /** + * Note that this is not the same as computing the union of two Regions (as the result of + * such a union may not be a shape which can be exactly represented by a Region). Instead, + * the result is simply big enough to contain both this Region and the one passed as a parameter. + * \param reg The Region to accumulate. This must be valid as defined by the isValid() function. + * \sa isValid() + */ void Region::accumulate(const Region& reg) { assert(reg.isValid()); //The result of accumulating an invalid region is not defined. @@ -89,9 +89,9 @@ namespace PolyVox m_iUpperZ = ((std::max)(m_iUpperZ, reg.getUpperZ())); } - //////////////////////////////////////////////////////////////////////////////// - /// Constructs a Region and clears all extents to zero. - //////////////////////////////////////////////////////////////////////////////// + /** + * Constructs a Region and clears all extents to zero. + */ Region::Region() :m_iLowerX(0) ,m_iLowerY(0) @@ -102,11 +102,11 @@ namespace PolyVox { } - //////////////////////////////////////////////////////////////////////////////// - /// Constructs a Region and sets the lower and upper corners to the specified values. - /// \param v3dLowerCorner The desired lower corner of the Region. - /// \param v3dUpperCorner The desired upper corner of the Region. - //////////////////////////////////////////////////////////////////////////////// + /** + * Constructs a Region and sets the lower and upper corners to the specified values. + * \param v3dLowerCorner The desired lower corner of the Region. + * \param v3dUpperCorner The desired upper corner of the Region. + */ Region::Region(const Vector3DInt32& v3dLowerCorner, const Vector3DInt32& v3dUpperCorner) :m_iLowerX(v3dLowerCorner.getX()) ,m_iLowerY(v3dLowerCorner.getY()) @@ -117,15 +117,15 @@ namespace PolyVox { } - //////////////////////////////////////////////////////////////////////////////// - /// Constructs a Region and sets the extents to the specified values. - /// \param iLowerX The desired lower 'x' extent of the Region. - /// \param iLowerY The desired lower 'y' extent of the Region. - /// \param iLowerZ The desired lower 'z' extent of the Region. - /// \param iUpperX The desired upper 'x' extent of the Region. - /// \param iUpperY The desired upper 'y' extent of the Region. - /// \param iUpperZ The desired upper 'z' extent of the Region. - //////////////////////////////////////////////////////////////////////////////// + /** + * Constructs a Region and sets the extents to the specified values. + * \param iLowerX The desired lower 'x' extent of the Region. + * \param iLowerY The desired lower 'y' extent of the Region. + * \param iLowerZ The desired lower 'z' extent of the Region. + * \param iUpperX The desired upper 'x' extent of the Region. + * \param iUpperY The desired upper 'y' extent of the Region. + * \param iUpperZ The desired upper 'z' extent of the Region. + */ Region::Region(int32_t iLowerX, int32_t iLowerY, int32_t iLowerZ, int32_t iUpperX, int32_t iUpperY, int32_t iUpperZ) :m_iLowerX(iLowerX) ,m_iLowerY(iLowerY) @@ -136,12 +136,12 @@ namespace PolyVox { } - //////////////////////////////////////////////////////////////////////////////// - /// Two regions are considered equal if all their extents match. - /// \param rhs The Region to compare to. - /// \return true if the Regions match. - /// \sa operator!= - //////////////////////////////////////////////////////////////////////////////// + /** + * Two regions are considered equal if all their extents match. + * \param rhs The Region to compare to. + * \return true if the Regions match. + * \sa operator!= + */ bool Region::operator==(const Region& rhs) const { return ((m_iLowerX == rhs.m_iLowerX) && (m_iLowerY == rhs.m_iLowerY) && (m_iLowerZ == rhs.m_iLowerZ) @@ -159,13 +159,13 @@ namespace PolyVox return !(*this == rhs); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in all directions. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in all directions. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPoint(const Vector3DFloat& pos, float boundary) const { return (pos.getX() <= m_iUpperX - boundary) @@ -176,13 +176,13 @@ namespace PolyVox && (pos.getZ() >= m_iLowerZ + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in all directions. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in all directions. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPoint(const Vector3DInt32& pos, uint8_t boundary) const { return (pos.getX() <= m_iUpperX - boundary) @@ -193,89 +193,89 @@ namespace PolyVox && (pos.getZ() >= m_iLowerZ + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in the 'x' direction. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in the 'x' direction. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPointInX(float pos, float boundary) const { return (pos <= m_iUpperX - boundary) && (pos >= m_iLowerX + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in the 'x' direction. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in the 'x' direction. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPointInX(int32_t pos, uint8_t boundary) const { return (pos <= m_iUpperX - boundary) && (pos >= m_iLowerX + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in the 'y' direction. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in the 'y' direction. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPointInY(float pos, float boundary) const { return (pos <= m_iUpperY - boundary) && (pos >= m_iLowerY + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in the 'y' direction. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in the 'y' direction. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPointInY(int32_t pos, uint8_t boundary) const { return (pos <= m_iUpperY - boundary) && (pos >= m_iLowerY + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in the 'z' direction. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in the 'z' direction. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPointInZ(float pos, float boundary) const { return (pos <= m_iUpperZ - boundary) && (pos >= m_iLowerZ + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// The boundary value can be used to ensure a position is only considered to be inside - /// the Region if it is that far in in the 'z' direction. Also, the test is inclusive such - /// that positions lying exactly on the edge of the Region are considered to be inside it. - /// \param pos The position to test. - /// \param boundary The desired boundary value. - //////////////////////////////////////////////////////////////////////////////// + /** + * The boundary value can be used to ensure a position is only considered to be inside + * the Region if it is that far in in the 'z' direction. Also, the test is inclusive such + * that positions lying exactly on the edge of the Region are considered to be inside it. + * \param pos The position to test. + * \param boundary The desired boundary value. + */ bool Region::containsPointInZ(int32_t pos, uint8_t boundary) const { return (pos <= m_iUpperZ - boundary) && (pos >= m_iLowerZ + boundary); } - //////////////////////////////////////////////////////////////////////////////// - /// After calling this functions, the extents of this Region are given by the intersection - /// of this Region and the one it was cropped to. - /// \param other The Region to crop to. - //////////////////////////////////////////////////////////////////////////////// + /** + * After calling this functions, the extents of this Region are given by the intersection + * of this Region and the one it was cropped to. + * \param other The Region to crop to. + */ void Region::cropTo(const Region& other) { m_iLowerX = ((std::max)(m_iLowerX, other.m_iLowerX)); @@ -286,11 +286,11 @@ namespace PolyVox m_iUpperZ = ((std::min)(m_iUpperZ, other.m_iUpperZ)); } - //////////////////////////////////////////////////////////////////////////////// - /// The same amount of growth is applied in all directions. Negative growth - /// is possible but you should prefer the shrink() function for clarity. - /// \param iAmount The amount to grow by. - //////////////////////////////////////////////////////////////////////////////// + /** + * The same amount of growth is applied in all directions. Negative growth + * is possible but you should prefer the shrink() function for clarity. + * \param iAmount The amount to grow by. + */ void Region::grow(int32_t iAmount) { m_iLowerX -= iAmount; @@ -302,13 +302,13 @@ namespace PolyVox m_iUpperZ += iAmount; } - //////////////////////////////////////////////////////////////////////////////// - /// The amount can be specified seperatly for each direction. Negative growth - /// is possible but you should prefer the shrink() function for clarity. - /// \param iAmountX The amount to grow by in 'x'. - /// \param iAmountY The amount to grow by in 'y'. - /// \param iAmountZ The amount to grow by in 'z'. - //////////////////////////////////////////////////////////////////////////////// + /** + * The amount can be specified seperatly for each direction. Negative growth + * is possible but you should prefer the shrink() function for clarity. + * \param iAmountX The amount to grow by in 'x'. + * \param iAmountY The amount to grow by in 'y'. + * \param iAmountZ The amount to grow by in 'z'. + */ void Region::grow(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ) { m_iLowerX -= iAmountX; @@ -320,48 +320,48 @@ namespace PolyVox m_iUpperZ += iAmountZ; } - //////////////////////////////////////////////////////////////////////////////// - /// The amount can be specified seperatly for each direction. Negative growth - /// is possible but you should prefer the shrink() function for clarity. - /// \param v3dAmount The amount to grow by (one component for each direction). - //////////////////////////////////////////////////////////////////////////////// + /** + * The amount can be specified seperatly for each direction. Negative growth + * is possible but you should prefer the shrink() function for clarity. + * \param v3dAmount The amount to grow by (one component for each direction). + */ void Region::grow(const Vector3DInt32& v3dAmount) { grow(v3dAmount.getX(), v3dAmount.getY(), v3dAmount.getZ()); } - //////////////////////////////////////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////////// + /** + */ bool Region::isValid(void) const { return (m_iUpperX >= m_iLowerX) && (m_iUpperY >= m_iLowerY) && (m_iUpperZ >= m_iLowerZ); } - //////////////////////////////////////////////////////////////////////////////// - /// \param iAmountX The amount to move the Region by in 'x'. - /// \param iAmountY The amount to move the Region by in 'y'. - /// \param iAmountZ The amount to move the Region by in 'z'. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iAmountX The amount to move the Region by in 'x'. + * \param iAmountY The amount to move the Region by in 'y'. + * \param iAmountZ The amount to move the Region by in 'z'. + */ void Region::shift(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ) { shiftLowerCorner(iAmountX, iAmountY, iAmountZ); shiftUpperCorner(iAmountX, iAmountY, iAmountZ); } - //////////////////////////////////////////////////////////////////////////////// - /// \param v3dAmount The amount to move the Region by. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param v3dAmount The amount to move the Region by. + */ void Region::shift(const Vector3DInt32& v3dAmount) { shiftLowerCorner(v3dAmount); shiftUpperCorner(v3dAmount); } - //////////////////////////////////////////////////////////////////////////////// - /// \param iAmountX The amount to move the lower corner by in 'x'. - /// \param iAmountY The amount to move the lower corner by in 'y'. - /// \param iAmountZ The amount to move the lower corner by in 'z'. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iAmountX The amount to move the lower corner by in 'x'. + * \param iAmountY The amount to move the lower corner by in 'y'. + * \param iAmountZ The amount to move the lower corner by in 'z'. + */ void Region::shiftLowerCorner(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ) { m_iLowerX += iAmountX; @@ -369,19 +369,19 @@ namespace PolyVox m_iLowerZ += iAmountZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \param v3dAmount The amount to move the lower corner by. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param v3dAmount The amount to move the lower corner by. + */ void Region::shiftLowerCorner(const Vector3DInt32& v3dAmount) { shiftLowerCorner(v3dAmount.getX(), v3dAmount.getY(), v3dAmount.getZ()); } - //////////////////////////////////////////////////////////////////////////////// - /// \param iAmountX The amount to move the upper corner by in 'x'. - /// \param iAmountY The amount to move the upper corner by in 'y'. - /// \param iAmountZ The amount to move the upper corner by in 'z'. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param iAmountX The amount to move the upper corner by in 'x'. + * \param iAmountY The amount to move the upper corner by in 'y'. + * \param iAmountZ The amount to move the upper corner by in 'z'. + */ void Region::shiftUpperCorner(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ) { m_iUpperX += iAmountX; @@ -389,19 +389,19 @@ namespace PolyVox m_iUpperZ += iAmountZ; } - //////////////////////////////////////////////////////////////////////////////// - /// \param v3dAmount The amount to move the upper corner by. - //////////////////////////////////////////////////////////////////////////////// + /** + * \param v3dAmount The amount to move the upper corner by. + */ void Region::shiftUpperCorner(const Vector3DInt32& v3dAmount) { shiftUpperCorner(v3dAmount.getX(), v3dAmount.getY(), v3dAmount.getZ()); } - //////////////////////////////////////////////////////////////////////////////// - /// The same amount of shrinkage is applied in all directions. Negative shrinkage - /// is possible but you should prefer the grow() function for clarity. - /// \param iAmount The amount to shrink by. - //////////////////////////////////////////////////////////////////////////////// + /** + * The same amount of shrinkage is applied in all directions. Negative shrinkage + * is possible but you should prefer the grow() function for clarity. + * \param iAmount The amount to shrink by. + */ void Region::shrink(int32_t iAmount) { m_iLowerX += iAmount; @@ -413,13 +413,13 @@ namespace PolyVox m_iUpperZ -= iAmount; } - //////////////////////////////////////////////////////////////////////////////// - /// The amount can be specified seperatly for each direction. Negative shrinkage - /// is possible but you should prefer the grow() function for clarity. - /// \param iAmountX The amount to shrink by in 'x'. - /// \param iAmountY The amount to shrink by in 'y'. - /// \param iAmountZ The amount to shrink by in 'z'. - //////////////////////////////////////////////////////////////////////////////// + /** + * The amount can be specified seperatly for each direction. Negative shrinkage + * is possible but you should prefer the grow() function for clarity. + * \param iAmountX The amount to shrink by in 'x'. + * \param iAmountY The amount to shrink by in 'y'. + * \param iAmountZ The amount to shrink by in 'z'. + */ void Region::shrink(int32_t iAmountX, int32_t iAmountY, int32_t iAmountZ) { m_iLowerX += iAmountX; @@ -431,11 +431,11 @@ namespace PolyVox m_iUpperZ -= iAmountZ; } - //////////////////////////////////////////////////////////////////////////////// - /// The amount can be specified seperatly for each direction. Negative shrinkage - /// is possible but you should prefer the grow() function for clarity. - /// \param v3dAmount The amount to shrink by (one component for each direction). - //////////////////////////////////////////////////////////////////////////////// + /** + * The amount can be specified seperatly for each direction. Negative shrinkage + * is possible but you should prefer the grow() function for clarity. + * \param v3dAmount The amount to shrink by (one component for each direction). + */ void Region::shrink(const Vector3DInt32& v3dAmount) { shrink(v3dAmount.getX(), v3dAmount.getY(), v3dAmount.getZ());