VoxelGridUtils.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agx/Vec3.h>
#include <agxCollide/BoundingAABB.h>
#include <agxRender/RenderSingleton.h>
 
namespace agxTerrain
{
  namespace VoxelGridUtils
  {
    /*
    This namespace deals with position-index conversions INSIDE the voxel grid.
    A position in the grid, aka grid position or voxel space position, is not the
    same as a local position in the terrain, which has it origo in the middle of
    the terrain. The voxel space origo is situated in the "bottomleft" corner of
    the terrain, coinciding with the terrain index (0, 0).
    */
 
    /*
    \param gridPosition - The position in voxel space.
    \param voxelSize - The side length of a voxel in the grid.
    \return the voxel index of the specified voxel space position.
    */
    inline agx::Vec3i getVoxelIndexFromGridPosition(agx::Vec3 gridPosition, agx::Real voxelSize)
    {
      gridPosition *= (1.0 / voxelSize);
      return agx::Vec3i(  (agx::Int)std::floor(gridPosition.x() + 0.5),
                          (agx::Int)std::floor(gridPosition.y() + 0.5),
                          (agx::Int)std::floor(gridPosition.z() + 0.5)  );
    }
 
    /*
    \param voxelIndex - the index of a voxel in grid.
    \param voxelSize - The side length of a voxel in the grid.
    \return the center position of the specified voxel in voxel space coordinates.
    */
    inline agx::Vec3 getGridPositionFromVoxelIndex(agx::Vec3i voxelIndex, agx::Real voxelSize)
    {
      return agx::Vec3( static_cast<agx::Real>((voxelIndex.x()))* voxelSize,
                        static_cast<agx::Real>((voxelIndex.y()))* voxelSize,
                        static_cast<agx::Real>((voxelIndex.z()))* voxelSize  );
    }
 
    inline agx::Bound3 transformBound( const agx::Bound3& bound,
                                              const agx::AffineMatrix4x4& gridInvTransform,
                                              agx::Real extend = agx::Real( 0 ) )
    {
      return agxCollide::BoundingAABB{ agx::Bound3{ bound.min() - agx::Vec3( extend ),
                                                    bound.max() + agx::Vec3( extend ) },
                                       gridInvTransform };
    }
 
    inline void renderVoxel(
      const agx::Vec3i voxel, const agxRender::Color& color, agx::Real voxelSize,
      const agx::AffineMatrix4x4& gridTransform, agx::Real size)
    {
      agx::Vec3 voxelCenter = getGridPositionFromVoxelIndex(voxel, voxelSize);
 
      // Find eight other corner points on the voxel and test them.
      agx::Real h = voxelSize * 0.5;
      agx::Vec3 corners[8];
      // Bottom
      corners[0] = voxelCenter + agx::Vec3(-h, -h, -h);
      corners[1] = voxelCenter + agx::Vec3(+h, -h, -h);
      corners[2] = voxelCenter + agx::Vec3(-h, +h, -h);
      corners[3] = voxelCenter + agx::Vec3(+h, +h, -h);
      // Top
      corners[4] = voxelCenter + agx::Vec3(-h, -h, +h);
      corners[5] = voxelCenter + agx::Vec3(+h, -h, +h);
      corners[6] = voxelCenter + agx::Vec3(-h, +h, +h);
      corners[7] = voxelCenter + agx::Vec3(+h, +h, +h);
 
      static const int edges[12][2] = {
        // Bottom square
        {0, 1},
        {1, 3},
        {3, 2},
        {2, 0},
 
        // Top square
        {4, 5},
        {5, 7},
        {7, 6},
        {6, 4},
 
        // Vertical connections
        {0, 4},
        {1, 5},
        {2, 6},
        {3, 7}
      };
 
      for (int e = 0; e < 12; ++e) {
        int a = edges[e][0];
        int b = edges[e][1];
 
        // Put line in world coordinates
        const agx::Vec3& p0 = corners[a] * gridTransform;
        const agx::Vec3& p1 = corners[b] * gridTransform;
 
        agxRender::RenderSingleton::instance()->add(p0, p1, size, color);
      }
    }
 
    inline void renderVoxels(
      const agx::Vec3iVector& voxels, const agxRender::Color& color, agx::Real voxelSize,
      const agx::AffineMatrix4x4& gridTransform, agx::Real size)
    {
      for (const auto& v : voxels)
        renderVoxel(v, color, voxelSize, gridTransform, size);
    }
  }
}