sphere.hpp

#ifndef BLUB_PROCEDURAL_VOXEL_EDIT_SPHERE_HPP
#define BLUB_PROCEDURAL_VOXEL_EDIT_SPHERE_HPP


// #include "blub/log/global.hpp"
#include "blub/math/axisAlignedBox.hpp"
#include "blub/math/math.hpp"
#include "blub/math/sphere.hpp"
#include "blub/math/transform.hpp"
#include "blub/procedural/voxel/edit/base.hpp"


namespace blub
{
namespace procedural
{
namespace voxel
{
namespace edit
{


template <class configType>
class sphere : public base<configType>
{
public:
    typedef configType t_config;
    typedef base<t_config> t_base;
    typedef sharedPointer<sphere<t_config> > pointer;
    typedef typename t_config::t_data t_voxel;

    static pointer create(const ::blub::sphere& desc)
    {
        return pointer(new sphere(desc));
    }

    void setSphere(const ::blub::sphere& desc)
    {
        m_sphere = desc;
    }
    const ::blub::sphere& getSphere() const
    {
        return m_sphere;
    }

    blub::axisAlignedBox getAxisAlignedBoundingBox(const blub::transform &trans) const override
    {
        const blub::axisAlignedBox aabb(m_sphere.getCenter() - blub::vector3(m_sphere.getRadius()),
                                  m_sphere.getCenter() + blub::vector3(m_sphere.getRadius()));
        return blub::axisAlignedBox(aabb.getMinimum()*trans.scale + trans.position,
                                    aabb.getMaximum()*trans.scale + trans.position);
    }

protected:
    bool calculateOneVoxel(const vector3& pos, t_voxel* resultVoxel) const override
    {
        const blub::real &squaredDist(pos.squaredDistance(m_sphere.getCenter()));
        const blub::real &radius(m_sphere.getRadius());
        if (squaredDist < (radius+1.)*(radius+1.))
        {
            if (squaredDist < (radius-1.)*(radius-1.))
            {
                resultVoxel->setInterpolationMax();
            }
            else
            {
                const blub::real &result(blub::math::clamp<blub::real>((radius-blub::math::sqrt(squaredDist))*127., -127., 127.));
                resultVoxel->setInterpolation(static_cast<blub::int8>(result));
            }
            return true;
        }
        return false;
    }

    sphere(const ::blub::sphere& desc)
        : m_sphere(desc)
    {
    }

protected:
    ::blub::sphere m_sphere;

};


}
}
}
}


#endif // VOXEL_EDIT_SPHERE_HPP