AuroraMiddleware/glm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'GTC_integer'

Browse Source
This commit is contained in:
Christophe Riccio 2014-11-21 22:50:00 +01:00
commit f98f2b107a
11 changed files with 223 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/glm.docx
View File

Binary file not shown.

BIN
doc/glm.pdf
View File

Binary file not shown.

12
glm/detail/func_common.inl
View File

@ -156,16 +156,20 @@ namespace detail
GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
{
GLM_STATIC_ASSERT(
std::numeric_limits<genFIType>::is_iec559 ||
(std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), "'sign' only accept signed inputs");
std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
"'sign' only accept signed inputs");
return genFIType(genFIType(0) < x) - (x < genFIType(0));
return static_cast<genFIType>(static_cast<genFIType>(0) < x) - static_cast<genFIType>(x < static_cast<genFIType>(0));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(sign, x);
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
"'sign' only accept signed inputs");
return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
}
// floor

65
glm/gtc/integer.hpp Normal file
View File

@ -0,0 +1,65 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// 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_integer
/// @file glm/gtc/integer.hpp
/// @date 2014-11-17 / 2014-11-17
/// @author Christophe Riccio
///
/// @see core (dependence)
/// @see gtc_integer (dependence)
///
/// @defgroup gtc_integer GLM_GTC_integer
/// @ingroup gtc
///
/// @brief Allow to perform bit operations on integer values
///
/// <glm/gtc/integer.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/func_integer.hpp"
#include "../detail/func_exponential.hpp"
#include <limits>
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTC_integer extension included")
#endif
namespace glm
{
/// @addtogroup gtc_integer
/// @{
/// Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
/// From GLM_GTC_integer extension.
template <typename genIUType>
GLM_FUNC_DECL genIUType log2(genIUType x);
/// @}
} //namespace glm
#include "integer.inl"

47
glm/gtc/integer.inl Normal file
View File

@ -0,0 +1,47 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// 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_integer
/// @file glm/gtc/integer.inl
/// @date 2014-11-17 / 2014-11-17
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x)
{
return 31u - findMSB(x);
}
template <>
struct compute_log2<false>
{
template <typename T>
GLM_FUNC_QUALIFIER T operator() (T const & Value) const
{
return Value <= static_cast<T>(1) ? T(0) : T(32) - nlz(Value - T(1));
}
};
}//namespace detail
}//namespace glm

6
glm/gtx/integer.hpp
View File

@ -39,6 +39,7 @@
// Dependency:
#include "../glm.hpp"
#include "../gtc/integer.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_integer extension included")
@ -57,11 +58,6 @@ namespace glm
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL int sqrt(int x);
//! Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
//! From GLM_GTX_integer extension.
template <typename genIUType>
GLM_FUNC_DECL genIUType log2(genIUType x);
//! Returns the floor log2 of x.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);

16
glm/gtx/integer.inl
View File

@ -53,21 +53,7 @@ namespace detail
x += (x >> 16);
return(x & 0x0000003f);
}
template <>
struct compute_log2<false>
{
template <typename T>
GLM_FUNC_QUALIFIER T operator() (T const & Value) const
{
#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
return Value <= static_cast<T>(1) ? T(0) : T(32) - nlz(Value - T(1));
#else
return T(32) - nlz(Value - T(1));
#endif
}
};
}//namespace _detail
}//namespace detail
// Henry Gordon Dietz: http://aggregate.org/MAGIC/
/*

2
readme.txt
View File

@ -55,7 +55,7 @@ Features:
- Added GLM_FORCE_NO_CTOR_INIT
- Added 'uninitialize' to explicitly not initialize a GLM type
- Added GTC_bitfield extension, promoted GTX_bit
- Added GTC_integer extension, promoted GTX_bit
- Added GTC_integer extension, promoted GTX_bit and GTX_integer
- Added GTC_round extension, promoted GTX_bit
- Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269

31
test/core/core_func_common.cpp
View File

@ -855,6 +855,12 @@ namespace sign
int Error = 0;
for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
{
glm::int32 Result = glm::sign(Data[i].Value);
Error += Data[i].Return == Result ? 0 : 1;
}
for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
{
glm::int32 Result = sign_cmp(Data[i].Value);
@ -888,11 +894,36 @@ namespace sign
return Error;
}
int test_i32vec4()
{
type<glm::i32vec4> const Data[] =
{
{glm::i32vec4( 1), glm::i32vec4( 1)},
{glm::i32vec4( 0), glm::i32vec4( 0)},
{glm::i32vec4( 2), glm::i32vec4( 1)},
{glm::i32vec4( 3), glm::i32vec4( 1)},
{glm::i32vec4(-1), glm::i32vec4(-1)},
{glm::i32vec4(-2), glm::i32vec4(-1)},
{glm::i32vec4(-3), glm::i32vec4(-1)}
};
int Error = 0;
for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::i32vec4>); ++i)
{
glm::i32vec4 Result = glm::sign(Data[i].Value);
Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1;
}
return Error;
}
int test()
{
int Error = 0;
Error += test_int32();
Error += test_i32vec4();
return Error;
}

1
test/gtc/CMakeLists.txt
View File

@ -1,6 +1,7 @@
glmCreateTestGTC(gtc_bitfield)
glmCreateTestGTC(gtc_constants)
glmCreateTestGTC(gtc_epsilon)
glmCreateTestGTC(gtc_integer)
glmCreateTestGTC(gtc_matrix_access)
glmCreateTestGTC(gtc_matrix_integer)
glmCreateTestGTC(gtc_matrix_inverse)

68
test/gtc/gtc_integer.cpp Normal file
View File

@ -0,0 +1,68 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2014-11-17
// Updated : 2014-11-17
// Licence : This source is under MIT licence
// File : test/gtc/integer.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#include <glm/gtc/integer.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtc/vec1.hpp>
#include <glm/vector_relational.hpp>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <ctime>
#include <cstdio>
#include <vector>
namespace log2_
{
int test()
{
int Error = 0;
int A0(glm::log2(10.f));
glm::ivec1 B0(glm::log2(glm::vec1(10.f)));
glm::ivec2 C0(glm::log2(glm::vec2(10.f)));
glm::ivec3 D0(glm::log2(glm::vec3(10.f)));
glm::ivec4 E0(glm::log2(glm::vec4(10.f)));
int A1 = glm::log2(int(10.f));
glm::ivec1 B1 = glm::log2(glm::ivec1(10.f));
glm::ivec2 C1 = glm::log2(glm::ivec2(10.f));
glm::ivec3 D1 = glm::log2(glm::ivec3(10.f));
glm::ivec4 E1 = glm::log2(glm::ivec4(10.f));
Error += A0 == A1 ? 0 : 1;
Error += glm::all(glm::equal(B0, B1)) ? 0 : 1;
Error += glm::all(glm::equal(C0, C1)) ? 0 : 1;
Error += glm::all(glm::equal(D0, D1)) ? 0 : 1;
Error += glm::all(glm::equal(E0, E1)) ? 0 : 1;
return Error;
}
int perf()
{
int Error = 0;
return Error;
}
}//namespace log2_
int main()
{
int Error(0);
Error += ::log2_::test();
# ifdef GLM_TEST_ENABLE_PERF
Error += ::log2_::perf();
# endif
return Error;
}