CS计算机代考程序代写 ///////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////
/// 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 class vecType, bool compute = false>
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vecType call(vecType const & v, T)
{
return v;
}
};

template class vecType>
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vecType call(vecType const & v, T Shift)
{
return v | (v >> Shift);
}
};

template class vecType, bool isSigned = true>
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vecType call(vecType const & x)
{
GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, “‘ceilPowerOfTwo’ only accept integer scalar or vector inputs”);

vecType const Sign(sign(x));

vecType v(abs(x));

v = v – static_cast(1);
v = v | (v >> static_cast(1));
v = v | (v >> static_cast(2));
v = v | (v >> static_cast(4));
v = compute_ceilShift= 2>::call(v, 8);
v = compute_ceilShift= 4>::call(v, 16);
v = compute_ceilShift= 8>::call(v, 32);
return (v + static_cast(1)) * Sign;
}
};

template class vecType>
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vecType call(vecType const & x)
{
GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, “‘ceilPowerOfTwo’ only accept integer scalar or vector inputs”);

vecType v(x);

v = v – static_cast(1);
v = v | (v >> static_cast(1));
v = v | (v >> static_cast(2));
v = v | (v >> static_cast(4));
v = compute_ceilShift= 2>::call(v, 8);
v = compute_ceilShift= 4>::call(v, 16);
v = compute_ceilShift= 8>::call(v, 32);
return v + static_cast(1);
}
};

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 class vecType>
GLM_FUNC_QUALIFIER vecType isPowerOfTwo(vecType const & Value)
{
vecType const Result(abs(Value));
return equal(Result & (Result – 1), vecType(0));
}

//////////////////
// ceilPowerOfTwo

template
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
{
return detail::compute_ceilPowerOfTwo::is_signed>::call(tvec1(value)).x;
}

template class vecType>
GLM_FUNC_QUALIFIER vecType ceilPowerOfTwo(vecType const & v)
{
return detail::compute_ceilPowerOfTwo::is_signed>::call(v);
}

///////////////////
// floorPowerOfTwo

template
GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value);
}

template class vecType>
GLM_FUNC_QUALIFIER vecType floorPowerOfTwo(vecType const & v)
{
return detail::functor1::call(floorPowerOfTwo, v);
}

///////////////////
// 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 class vecType>
GLM_FUNC_QUALIFIER vecType roundPowerOfTwo(vecType const & v)
{
return detail::functor1::call(roundPowerOfTwo, v);
}

////////////////
// isMultiple

template
GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple)
{
return isMultiple(tvec1(Value), tvec1(Multiple)).x;
}

template class vecType>
GLM_FUNC_QUALIFIER vecType isMultiple(vecType const & Value, T Multiple)
{
return (Value % Multiple) == vecType(0);
}

template class vecType>
GLM_FUNC_QUALIFIER vecType isMultiple(vecType const & Value, vecType const & Multiple)
{
return (Value % Multiple) == vecType(0);
}

//////////////////////
// ceilMultiple

template
GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
{
return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple);
}

template class vecType>
GLM_FUNC_QUALIFIER vecType ceilMultiple(vecType const & Source, vecType const & Multiple)
{
return detail::functor2::call(ceilMultiple, Source, Multiple);
}

//////////////////////
// floorMultiple

template
GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
{
return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple);
}

template class vecType>
GLM_FUNC_QUALIFIER vecType floorMultiple(vecType const & Source, vecType const & Multiple)
{
return detail::functor2::call(floorMultiple, Source, Multiple);
}

//////////////////////
// roundMultiple

template
GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
{
return detail::compute_roundMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple);
}

template class vecType>
GLM_FUNC_QUALIFIER vecType roundMultiple(vecType const & Source, vecType const & Multiple)
{
return detail::functor2::call(roundMultiple, Source, Multiple);
}
}//namespace glm