suwako / VulkanExample

master
ブランチ master
VulkanExample / dep / include / glm / gtc / round.inl
4.4 KB、155行 生 Blame 履歴
1/// @ref gtc_round
2
3#include "../integer.hpp"
4#include "../ext/vector_integer.hpp"
5
6namespace glm{
7namespace detail
8{
9 template<bool is_float, bool is_signed>
10 struct compute_roundMultiple {};
11
12 template<>
13 struct compute_roundMultiple<true, true>
14 {
15 template<typename genType>
16 GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
17 {
18 if (Source >= genType(0))
19 return Source - std::fmod(Source, Multiple);
20 else
21 {
22 genType Tmp = Source + genType(1);
23 return Tmp - std::fmod(Tmp, Multiple) - Multiple;
24 }
25 }
26 };
27
28 template<>
29 struct compute_roundMultiple<false, false>
30 {
31 template<typename genType>
32 GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
33 {
34 if (Source >= genType(0))
35 return Source - Source % Multiple;
36 else
37 {
38 genType Tmp = Source + genType(1);
39 return Tmp - Tmp % Multiple - Multiple;
40 }
41 }
42 };
43
44 template<>
45 struct compute_roundMultiple<false, true>
46 {
47 template<typename genType>
48 GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
49 {
50 if (Source >= genType(0))
51 return Source - Source % Multiple;
52 else
53 {
54 genType Tmp = Source + genType(1);
55 return Tmp - Tmp % Multiple - Multiple;
56 }
57 }
58 };
59}//namespace detail
60
61 //////////////////
62 // ceilPowerOfTwo
63
64 template<typename genType>
65 GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
66 {
67 return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits<genType>::is_signed>::call(vec<1, genType, defaultp>(value)).x;
68 }
69
70 template<length_t L, typename T, qualifier Q>
71 GLM_FUNC_QUALIFIER vec<L, T, Q> ceilPowerOfTwo(vec<L, T, Q> const& v)
72 {
73 return detail::compute_ceilPowerOfTwo<L, T, Q, std::numeric_limits<T>::is_signed>::call(v);
74 }
75
76 ///////////////////
77 // floorPowerOfTwo
78
79 template<typename genType>
80 GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
81 {
82 return isPowerOfTwo(value) ? value : static_cast<genType>(1) << findMSB(value);
83 }
84
85 template<length_t L, typename T, qualifier Q>
86 GLM_FUNC_QUALIFIER vec<L, T, Q> floorPowerOfTwo(vec<L, T, Q> const& v)
87 {
88 return detail::functor1<vec, L, T, T, Q>::call(floorPowerOfTwo, v);
89 }
90
91 ///////////////////
92 // roundPowerOfTwo
93
94 template<typename genIUType>
95 GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value)
96 {
97 if(isPowerOfTwo(value))
98 return value;
99
100 genIUType const prev = static_cast<genIUType>(1) << findMSB(value);
101 genIUType const next = prev << static_cast<genIUType>(1);
102 return (next - value) < (value - prev) ? next : prev;
103 }
104
105 template<length_t L, typename T, qualifier Q>
106 GLM_FUNC_QUALIFIER vec<L, T, Q> roundPowerOfTwo(vec<L, T, Q> const& v)
107 {
108 return detail::functor1<vec, L, T, T, Q>::call(roundPowerOfTwo, v);
109 }
110
111 //////////////////////
112 // ceilMultiple
113
114 template<typename genType>
115 GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
116 {
117 return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
118 }
119
120 template<length_t L, typename T, qualifier Q>
121 GLM_FUNC_QUALIFIER vec<L, T, Q> ceilMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
122 {
123 return detail::functor2<vec, L, T, Q>::call(ceilMultiple, Source, Multiple);
124 }
125
126 //////////////////////
127 // floorMultiple
128
129 template<typename genType>
130 GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
131 {
132 return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
133 }
134
135 template<length_t L, typename T, qualifier Q>
136 GLM_FUNC_QUALIFIER vec<L, T, Q> floorMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
137 {
138 return detail::functor2<vec, L, T, Q>::call(floorMultiple, Source, Multiple);
139 }
140
141 //////////////////////
142 // roundMultiple
143
144 template<typename genType>
145 GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
146 {
147 return detail::compute_roundMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
148 }
149
150 template<length_t L, typename T, qualifier Q>
151 GLM_FUNC_QUALIFIER vec<L, T, Q> roundMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
152 {
153 return detail::functor2<vec, L, T, Q>::call(roundMultiple, Source, Multiple);
154 }
155}//namespace glm