Constants.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_CONSTANTS_HPP
#define CUBBYFLOW_CONSTANTS_HPP
 
#include <Core/Utils/Macros.hpp>
 
namespace CubbyFlow
{
// MARK: Zero
constexpr size_t ZERO_SIZE = 0;
constexpr ssize_t ZERO_SSIZE = 0;
 
template <typename T>
constexpr T Zero()
{
    return 0;
}
 
template <>
constexpr float Zero<float>()
{
    return 0.f;
}
 
template <>
constexpr double Zero<double>()
{
    return 0.0;
}
 
// MARK: One
constexpr size_t ONE_SIZE = 1;
 
constexpr ssize_t ONE_SSIZE = 1;
 
template <typename T>
constexpr T One()
{
    return 1;
}
 
template <>
constexpr float One<float>()
{
    return 1.f;
}
 
template <>
constexpr double One<double>()
{
    return 1.0;
}
 
// MARK: PI
constexpr float PI_FLOAT = 3.14159265358979323846264338327950288f;
constexpr double PI_DOUBLE = 3.14159265358979323846264338327950288;
 
template <typename T>
constexpr T PI()
{
    return static_cast<T>(PI_DOUBLE);
}
 
template <>
constexpr float PI<float>()
{
    return PI_FLOAT;
}
 
template <>
constexpr double PI<double>()
{
    return PI_DOUBLE;
}
 
// MARK: PI/2
constexpr float HALF_PI_FLOAT = 1.57079632679489661923132169163975144f;
 
constexpr double HALF_PI_DOUBLE = 1.57079632679489661923132169163975144;
 
template <typename T>
constexpr T HalfPI()
{
    return static_cast<T>(HALF_PI_DOUBLE);
}
 
template <>
constexpr float HalfPI<float>()
{
    return HALF_PI_FLOAT;
}
 
template <>
constexpr double HalfPI<double>()
{
    return HALF_PI_DOUBLE;
}
 
// MARK: PI/4
constexpr float QUARTER_PI_FLOAT = 0.785398163397448309615660845819875721f;
 
constexpr double QUARTER_PI_DOUBLE = 0.785398163397448309615660845819875721;
 
template <typename T>
constexpr T QuarterPI()
{
    return static_cast<T>(QUARTER_PI_DOUBLE);
}
 
template <>
constexpr float QuarterPI<float>()
{
    return QUARTER_PI_FLOAT;
}
 
template <>
constexpr double QuarterPI<double>()
{
    return QUARTER_PI_DOUBLE;
}
 
// MARK: 2*PI
constexpr float TWO_PI_FLOAT = static_cast<float>(2.0 * PI_DOUBLE);
 
constexpr double TWO_PI_DOUBLE = 2.0 * PI_DOUBLE;
 
template <typename T>
constexpr T TwoPI()
{
    return static_cast<T>(TWO_PI_DOUBLE);
}
 
template <>
constexpr float TwoPI<float>()
{
    return TWO_PI_FLOAT;
}
 
template <>
constexpr double TwoPI<double>()
{
    return TWO_PI_DOUBLE;
}
 
// MARK: 4*PI
constexpr float FOUR_PI_FLOAT = static_cast<float>(4.0 * PI_DOUBLE);
 
constexpr double FOUR_PI_DOUBLE = 4.0 * PI_DOUBLE;
 
template <typename T>
constexpr T FourPI()
{
    return static_cast<T>(FOUR_PI_DOUBLE);
}
 
template <>
constexpr float FourPI<float>()
{
    return FOUR_PI_FLOAT;
}
 
template <>
constexpr double FourPI<double>()
{
    return FOUR_PI_DOUBLE;
}
 
// MARK: 1/PI
constexpr float INV_PI_FLOAT = static_cast<float>(1.0 / PI_DOUBLE);
 
constexpr double INV_PI_DOUBLE = 1.0 / PI_DOUBLE;
 
template <typename T>
constexpr T InvPI()
{
    return static_cast<T>(INV_PI_DOUBLE);
}
 
template <>
constexpr float InvPI<float>()
{
    return INV_PI_FLOAT;
}
 
template <>
constexpr double InvPI<double>()
{
    return INV_PI_DOUBLE;
}
 
// MARK: 1/2*PI
constexpr float INV_TWO_PI_FLOAT = static_cast<float>(0.5 / PI_DOUBLE);
 
constexpr double INV_TWO_PI_DOUBLE = 0.5 / PI_DOUBLE;
 
template <typename T>
constexpr T InvTwoPI()
{
    return static_cast<T>(INV_TWO_PI_DOUBLE);
}
 
template <>
constexpr float InvTwoPI<float>()
{
    return INV_TWO_PI_FLOAT;
}
 
template <>
constexpr double InvTwoPI<double>()
{
    return INV_TWO_PI_DOUBLE;
}
 
// MARK: 1/4*PI
constexpr float INV_FOUR_PI_FLOAT = static_cast<float>(0.25 / PI_DOUBLE);
 
constexpr double INV_FOUR_PI_DOUBLE = 0.25 / PI_DOUBLE;
 
template <typename T>
constexpr T InvFourPI()
{
    return static_cast<T>(INV_FOUR_PI_DOUBLE);
}
 
template <>
constexpr float InvFourPI<float>()
{
    return INV_FOUR_PI_FLOAT;
}
 
template <>
constexpr double InvFourPI<double>()
{
    return INV_FOUR_PI_DOUBLE;
}
 
// MARK: Physics
constexpr float GRAVITY_FLOAT = -9.8f;
constexpr double GRAVITY = -9.8;
 
constexpr float WATER_DENSITY_FLOAT = 1000.0f;
constexpr double WATER_DENSITY = 1000.0;
 
constexpr float SPEED_OF_SOUND_IN_WATER_FLOAT = 1482.0f;
constexpr double SPEED_OF_SOUND_IN_WATER = 1482.0;
 
// MARK: Common enums
constexpr int DIRECTION_NONE = 0;
 
constexpr int DIRECTION_LEFT = 1 << 0;
 
constexpr int DIRECTION_RIGHT = 1 << 1;
 
constexpr int DIRECTION_DOWN = 1 << 2;
 
constexpr int DIRECTION_UP = 1 << 3;
 
constexpr int DIRECTION_BACK = 1 << 4;
 
constexpr int DIRECTION_FRONT = 1 << 5;
 
constexpr int DIRECTION_ALL = DIRECTION_LEFT | DIRECTION_RIGHT |
                              DIRECTION_DOWN | DIRECTION_UP | DIRECTION_BACK |
                              DIRECTION_FRONT;
}  // namespace CubbyFlow
 
#endif