///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 – 2015 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the “Software”), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_round
/// @file glm/gtc/round.inl
/// @date 2014-11-03 / 2014-11-03
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
namespace detail
{
template
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vecType
{
return v;
}
};
template
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vecType
{
return v | (v >> Shift);
}
};
template
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vecType
{
GLM_STATIC_ASSERT(!std::numeric_limits
vecType
vecType
v = v – static_cast
v = v | (v >> static_cast
v = v | (v >> static_cast
v = v | (v >> static_cast
v = compute_ceilShift
v = compute_ceilShift
v = compute_ceilShift
return (v + static_cast
}
};
template
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vecType
{
GLM_STATIC_ASSERT(!std::numeric_limits
vecType
v = v – static_cast
v = v | (v >> static_cast
v = v | (v >> static_cast
v = v | (v >> static_cast
v = compute_ceilShift
v = compute_ceilShift
v = compute_ceilShift
return v + static_cast
}
};
template
struct compute_ceilMultiple{};
template <>
struct compute_ceilMultiple
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source > genType(0))
{
genType Tmp = Source – genType(1);
return Tmp + (Multiple – std::fmod(Tmp, Multiple));
}
else
return Source + std::fmod(-Source, Multiple);
}
};
template <>
struct compute_ceilMultiple
{
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
genType Tmp = Source – genType(1);
return Tmp + (Multiple – (Tmp % Multiple));
}
};
template <>
struct compute_ceilMultiple
{
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source > genType(0))
{
genType Tmp = Source – genType(1);
return Tmp + (Multiple – (Tmp % Multiple));
}
else
return Source + (-Source % Multiple);
}
};
template
struct compute_floorMultiple{};
template <>
struct compute_floorMultiple
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source – std::fmod(Source, Multiple);
else
{
genType Tmp = Source + genType(1);
return Tmp – std::fmod(Tmp, Multiple) – Multiple;
}
}
};
template <>
struct compute_floorMultiple
{
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source – Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp – Tmp % Multiple – Multiple;
}
}
};
template <>
struct compute_floorMultiple
{
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source – Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp – Tmp % Multiple – Multiple;
}
}
};
template
struct compute_roundMultiple{};
template <>
struct compute_roundMultiple
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source – std::fmod(Source, Multiple);
else
{
genType Tmp = Source + genType(1);
return Tmp – std::fmod(Tmp, Multiple) – Multiple;
}
}
};
template <>
struct compute_roundMultiple
{
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source – Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp – Tmp % Multiple – Multiple;
}
}
};
template <>
struct compute_roundMultiple
{
template
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source – Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp – Tmp % Multiple – Multiple;
}
}
};
}//namespace detail
////////////////
// isPowerOfTwo
template
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
{
genType const Result = glm::abs(Value);
return !(Result & (Result – 1));
}
template
GLM_FUNC_QUALIFIER vecType
{
vecType
return equal(Result & (Result – 1), vecType
}
//////////////////
// ceilPowerOfTwo
template
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
{
return detail::compute_ceilPowerOfTwo
}
template
GLM_FUNC_QUALIFIER vecType
{
return detail::compute_ceilPowerOfTwo
}
///////////////////
// floorPowerOfTwo
template
GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value);
}
template
GLM_FUNC_QUALIFIER vecType
{
return detail::functor1
}
///////////////////
// roundPowerOfTwo
template
GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value)
{
if(isPowerOfTwo(value))
return value;
genIUType const prev = highestBitValue(value);
genIUType const next = prev << 1;
return (next - value) < (value - prev) ? next : prev;
}
template
GLM_FUNC_QUALIFIER vecType
{
return detail::functor1
}
////////////////
// isMultiple
template
GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple)
{
return isMultiple(tvec1
}
template
GLM_FUNC_QUALIFIER vecType
{
return (Value % Multiple) == vecType
}
template
GLM_FUNC_QUALIFIER vecType
{
return (Value % Multiple) == vecType
}
//////////////////////
// ceilMultiple
template
GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
{
return detail::compute_ceilMultiple
}
template
GLM_FUNC_QUALIFIER vecType
{
return detail::functor2
}
//////////////////////
// floorMultiple
template
GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
{
return detail::compute_floorMultiple
}
template
GLM_FUNC_QUALIFIER vecType
{
return detail::functor2
}
//////////////////////
// roundMultiple
template
GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
{
return detail::compute_roundMultiple
}
template
GLM_FUNC_QUALIFIER vecType
{
return detail::functor2
}
}//namespace glm