OWL
OptiX7 Wrapper Library
functors.h
Go to the documentation of this file.
1 // ======================================================================== //
2 // Copyright 2018-2019 Ingo Wald //
3 // //
4 // Licensed under the Apache License, Version 2.0 (the "License"); //
5 // you may not use this file except in compliance with the License. //
6 // You may obtain a copy of the License at //
7 // //
8 // http://www.apache.org/licenses/LICENSE-2.0 //
9 // //
10 // Unless required by applicable law or agreed to in writing, software //
11 // distributed under the License is distributed on an "AS IS" BASIS, //
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
13 // See the License for the specific language governing permissions and //
14 // limitations under the License. //
15 // ======================================================================== //
16 
17 #pragma once
18 
19 #include <type_traits>
20 
21 namespace owl {
22  namespace common {
23 
24  // =======================================================
25  // vector specializations of those scalar functors
26  // =======================================================
27 
28  template<typename T, int N> inline __both__
29  bool any_less_than(const vec_t<T,N> &a, const vec_t<T,N> &b)
30  { return common::any(lt(a,b)); }
31 
32  template<typename T, int N> inline __both__
33  bool all_less_than(const vec_t<T,N> &a, const vec_t<T,N> &b)
34  { return common::all(lt(a,b)); }
35 
36  template<typename T, int N> inline __both__
37  bool any_greater_than(const vec_t<T,N> &a, const vec_t<T,N> &b)
38  { return common::any(gt(a,b)); }
39 
42  template<typename T, int N> inline __both__
43  bool any_greater_or_equal(const vec_t<T,N> &a, const vec_t<T,N> &b)
44  { return common::any(ge(a,b)); }
45 
46  // -------------------------------------------------------
47  // unary functors
48  // -------------------------------------------------------
49 
50  template<typename T>
51  inline __both__ T clamp(const T &val, const T &lo, const T &hi)
52  { return min(hi,max(lo,val)); }
53 
54  template<typename T>
55  inline __both__ T clamp(const T &val, const T &hi)
56  { return clamp(val,(T)0,hi); }
57 
58 #define _define_float_functor(func) \
59  template<typename T> inline __both__ vec_t<T,2> func(const vec_t<T,2> &v) \
60  { return vec_t<T,2>(owl::common::func(v.x),owl::common::func(v.y)); } \
61  \
62  template<typename T> inline __both__ vec_t<T,3> func(const vec_t<T,3> &v) \
63  { return vec_t<T,3>(owl::common::func(v.x),owl::common::func(v.y),owl::common::func(v.z)); } \
64  \
65  template<typename T> inline __both__ vec_t<T,4> func(const vec_t<T,4> &v) \
66  { return vec_t<T,4>(owl::common::func(v.x),owl::common::func(v.y),owl::common::func(v.z),owl::common::func(v.w)); } \
67 
68  _define_float_functor(rcp)
69  _define_float_functor(sin)
70  _define_float_functor(cos)
71  _define_float_functor(abs)
72  _define_float_functor(saturate)
73 
74 #undef _define_float_functor
75 
76  // -------------------------------------------------------
77  // binary functors
78  // -------------------------------------------------------
79  // template<typename T>
80  // __both__ vec_t<T,2> divRoundUp(const vec_t<T,2> &a, const vec_t<T,2> &b)
81  // { return vec_t<T,2>(divRoundUp(a.x,b.x),divRoundUp(a.y,b.y)); }
82 
83  // template<typename T>
84  // __both__ vec_t<T,3> divRoundUp(const vec_t<T,3> &a, const vec_t<T,3> &b)
85  // { return vec_t<T,3>(divRoundUp(a.x,b.x),divRoundUp(a.y,b.y),divRoundUp(a.z,b.z)); }
86 
87 #define _define_binary_functor(fct) \
88  template<typename T> \
89  inline __both__ vec_t<T,1> fct(const vec_t<T,1> &a, const vec_t<T,1> &b) \
90  { \
91  return vec_t<T,1>(fct(a.x,b.x)); \
92  } \
93  \
94  template<typename T> \
95  inline __both__ vec_t<T,2> fct(const vec_t<T,2> &a, const vec_t<T,2> &b) \
96  { \
97  return vec_t<T,2>(fct(a.x,b.x), \
98  fct(a.y,b.y)); \
99  } \
100  \
101  template<typename T> \
102  inline __both__ vec_t<T,3> fct(const vec_t<T,3> &a, const vec_t<T,3> &b) \
103  { \
104  return vec_t<T,3>(fct(a.x,b.x), \
105  fct(a.y,b.y), \
106  fct(a.z,b.z)); \
107  } \
108  \
109  template<typename T1, typename T2> \
110  inline __both__ vec_t<typename BinaryOpResultType<T1,T2>::type,3> \
111  fct(const vec_t<T1,3> &a, const vec_t<T2,3> &b) \
112  { \
113  return vec_t<typename BinaryOpResultType<T1,T2>::type,3> \
114  (fct(a.x,b.x), \
115  fct(a.y,b.y), \
116  fct(a.z,b.z)); \
117  } \
118  \
119  template<typename T> \
120  inline __both__ vec_t<T,4> fct(const vec_t<T,4> &a, const vec_t<T,4> &b) \
121  { \
122  return vec_t<T,4>(fct(a.x,b.x), \
123  fct(a.y,b.y), \
124  fct(a.z,b.z), \
125  fct(a.w,b.w)); \
126  } \
127 
128 
129  _define_binary_functor(divRoundUp)
130  _define_binary_functor(min)
131  _define_binary_functor(max)
132 #undef _define_binary_functor
133 
134 
135 
136 
137 
138 
139  // -------------------------------------------------------
140  // binary operators
141  // -------------------------------------------------------
142 #define _define_operator(op) \
143  /* vec op vec */ \
144  template<typename T> \
145  inline __both__ vec_t<T,2> operator op(const vec_t<T,2> &a, \
146  const vec_t<T,2> &b) \
147  { return vec_t<T,2>(a.x op b.x, a.y op b.y); } \
148  \
149  template<typename T> \
150  inline __both__ vec_t<T,3> operator op(const vec_t<T,3> &a, \
151  const vec_t<T,3> &b) \
152  { return vec_t<T,3>(a.x op b.x, a.y op b.y, a.z op b.z); } \
153  \
154  template<typename T> \
155  inline __both__ vec_t<T,4> operator op(const vec_t<T,4> &a, \
156  const vec_t<T,4> &b) \
157  { return vec_t<T,4>(a.x op b.x,a.y op b.y,a.z op b.z,a.w op b.w); } \
158  \
159  /* vec op scalar */ \
160  template<typename T> \
161  inline __both__ vec_t<T,2> operator op(const vec_t<T,2> &a, \
162  const T &b) \
163  { return vec_t<T,2>(a.x op b, a.y op b); } \
164  \
165  template<typename T1, typename T2> \
166  inline __both__ vec_t<typename BinaryOpResultType<T1,T2>::type,3> \
167  operator op(const vec_t<T1,3> &a, const T2 &b) \
168  { return vec_t<typename BinaryOpResultType<T1,T2>::type,3> \
169  (a.x op b, a.y op b, a.z op b); \
170  } \
171  \
172  template<typename T> \
173  inline __both__ vec_t<T,4> operator op(const vec_t<T,4> &a, \
174  const T &b) \
175  { return vec_t<T,4>(a.x op b, a.y op b, a.z op b, a.w op b); } \
176  \
177  /* scalar op vec */ \
178  template<typename T> \
179  inline __both__ vec_t<T,2> operator op(const T &a, \
180  const vec_t<T,2> &b) \
181  { return vec_t<T,2>(a op b.x, a op b.y); } \
182  \
183  template<typename T> \
184  inline __both__ vec_t<T,3> operator op(const T &a, \
185  const vec_t<T,3> &b) \
186  { return vec_t<T,3>(a op b.x, a op b.y, a op b.z); } \
187  \
188  template<typename T> \
189  inline __both__ vec_t<T,4> operator op(const T &a, \
190  const vec_t<T,4> &b) \
191  { return vec_t<T,4>(a op b.x, a op b.y, a op b.z, a op b.w); } \
192  \
193  \
194 
195  _define_operator(*);
196  _define_operator(/);
197  _define_operator(+);
198  _define_operator(-);
199 
200 #undef _define_operator
201 
202 
203 
204 
205  // -------------------------------------------------------
206  // unary operators
207  // -------------------------------------------------------
208 
209  template<typename T>
210  inline __both__ vec_t<T,2> operator-(const vec_t<T,2> &v)
211  { return vec_t<T,2>(-v.x, -v.y); }
212 
213  template<typename T>
214  inline __both__ vec_t<T,2> operator+(const vec_t<T,2> &v)
215  { return vec_t<T,2>(v.x, v.y); }
216 
217  template<typename T>
218  inline __both__ vec_t<T,3> operator-(const vec_t<T,3> &v)
219  { return vec_t<T,3>(-v.x, -v.y, -v.z); }
220 
221  template<typename T>
222  inline __both__ vec_t<T,3> operator+(const vec_t<T,3> &v)
223  { return vec_t<T,3>(v.x, v.y, v.z); }
224 
225 
226 
227  // -------------------------------------------------------
228  // binary op-assign operators
229  // -------------------------------------------------------
230 #define _define_op_assign_operator(operator_op,op) \
231  /* vec op vec */ \
232  template<typename T, typename OT> \
233  inline __both__ vec_t<T,2> &operator_op(vec_t<T,2> &a, \
234  const vec_t<OT,2> &b) \
235  { \
236  a.x op (T)b.x; \
237  a.y op (T)b.y; \
238  return a; \
239  } \
240  \
241  template<typename T, typename OT> \
242  inline __both__ vec_t<T,3> &operator_op(vec_t<T,3> &a, \
243  const vec_t<OT,3> &b) \
244  { \
245  a.x op (T)b.x; \
246  a.y op (T)b.y; \
247  a.z op (T)b.z; \
248  return a; \
249  } \
250  \
251  template<typename T, typename OT> \
252  inline __both__ vec_t<T,4> &operator_op(vec_t<T,4> &a, \
253  const vec_t<OT,4> &b) \
254  { \
255  a.x op (T)b.x; \
256  a.y op (T)b.y; \
257  a.z op (T)b.z; \
258  a.w op (T)b.w; \
259  return a; \
260  } \
261  \
262  /* vec op scalar */ \
263  template<typename T, typename OT> \
264  inline __both__ vec_t<T,2> &operator_op(vec_t<T,2> &a, \
265  const OT &b) \
266  { a.x op (T)b; a.y op (T)b; return a; } \
267  \
268  template<typename T, typename OT> \
269  inline __both__ vec_t<T,3> &operator_op(vec_t<T,3> &a, \
270  const OT &b) \
271  { a.x op (T)b; a.y op (T)b; a.z op (T)b; return a; } \
272  \
273  template<typename T, typename OT> \
274  inline __both__ vec_t<T,4> &operator_op(vec_t<T,4> &a, \
275  const OT &b) \
276  { a.x op (T)b; a.y op (T)b; a.z op (T)b; a.w op (T)b; return a; } \
277 
278  _define_op_assign_operator(operator*=,*=);
279  _define_op_assign_operator(operator/=,/=);
280  _define_op_assign_operator(operator+=,+=);
281  _define_op_assign_operator(operator-=,-=);
282 
283 #undef _define_op_assign_operator
284 
285 
286  template<typename T>
287  __both__ T reduce_min(const vec_t<T,1> &v) { return v.x; }
288  template<typename T>
289  __both__ T reduce_min(const vec_t<T,2> &v) { return min(v.x,v.y); }
290  template<typename T>
291  __both__ T reduce_min(const vec_t<T,3> &v) { return min(min(v.x,v.y),v.z); }
292  template<typename T>
293  __both__ T reduce_min(const vec_t<T,4> &v) { return min(min(v.x,v.y),min(v.z,v.w)); }
294  template<typename T>
295  __both__ T reduce_max(const vec_t<T,2> &v) { return max(v.x,v.y); }
296  template<typename T>
297  __both__ T reduce_max(const vec_t<T,3> &v) { return max(max(v.x,v.y),v.z); }
298  template<typename T>
299  __both__ T reduce_max(const vec_t<T,4> &v) { return max(max(v.x,v.y),max(v.z,v.w)); }
300 
301 
302  template<typename T, int N>
303  __both__ vec_t<T,3> madd(const vec_t<T,N> &a, const vec_t<T,N> &b, const vec_t<T,N> &c)
304  {
305  return a*b + c;
306  }
307 
308 
309  template<typename T, int N>
310  __both__ int arg_max(const vec_t<T,N> &v)
311  {
312  int biggestDim = 0;
313  for (int i=1;i<N;i++)
314  if ((v[i]) > (v[biggestDim])) biggestDim = i;
315  return biggestDim;
316  }
317 
318  template<typename T, int N>
319  __both__ int arg_min(const vec_t<T,N> &v)
320  {
321  int biggestDim = 0;
322  for (int i=1;i<N;i++)
323  if ((v[i]) < (v[biggestDim])) biggestDim = i;
324  return biggestDim;
325  }
326 
327 
328  // less, for std::set, std::map, etc
329  template<typename T>
330  __both__ bool operator<(const vec_t<T,3> &a, const vec_t<T,3> &b)
331  {
332  if (a.x < b.x) return true;
333  if (a.x == b.x && a.y < b.y) return true;
334  if (a.x == b.x && a.y == b.y && a.z < b.z) return true;
335  return false;
336  // return
337  // (a.x < b.x) |
338  // ((a.x == b.x) & ((a.y < b.y) |
339  // ((a.y == b.y) & (a.z < b.z))));
340  }
341 
343  inline __both__ vec3f randomColor(int i)
344  {
345  int r = unsigned(i)*13*17 + 0x234235;
346  int g = unsigned(i)*7*3*5 + 0x773477;
347  int b = unsigned(i)*11*19 + 0x223766;
348  return vec3f((r&255)/255.f,
349  (g&255)/255.f,
350  (b&255)/255.f);
351  }
352 
354  inline __both__ vec3f randomColor(size_t idx)
355  {
356  unsigned int r = (unsigned int)(idx*13*17 + 0x234235);
357  unsigned int g = (unsigned int)(idx*7*3*5 + 0x773477);
358  unsigned int b = (unsigned int)(idx*11*19 + 0x223766);
359  return vec3f((r&255)/255.f,
360  (g&255)/255.f,
361  (b&255)/255.f);
362  }
363 
365  template<typename T>
366  inline __both__ vec3f randomColor(const T *ptr)
367  {
368  return randomColor((size_t)ptr);
369  }
370 
371  inline __both__ float sqrt(const float v) { return sqrtf(v); }
372 inline __both__ vec2f sqrt(const vec2f v) { return vec2f(sqrtf(v.x),sqrtf(v.y)); }
373 inline __both__ vec3f sqrt(const vec3f v) { return vec3f(sqrtf(v.x),sqrtf(v.y),sqrtf(v.z)); }
374 inline __both__ vec4f sqrt(const vec4f v) { return vec4f(sqrtf(v.x),sqrtf(v.y),sqrtf(v.z),sqrtf(v.w)); }
375 
376  } // ::owl::common
377 } // ::owl
378 
owl::common::sqrt
__both__ float sqrt(const float v)
Definition: functors.h:371
owl::common::vec_t< T, 4 >::z
T z
Definition: vec.h:282
owl::common::_define_operator
_define_operator(/)
owl::common::vec_t< T, 3 >::z
T z
Definition: vec.h:194
owl::common::reduce_min
__both__ T reduce_min(const vec_t< T, 1 > &v)
Definition: functors.h:287
owl::common::madd
__both__ vec_t< T, 3 > madd(const vec_t< T, N > &a, const vec_t< T, N > &b, const vec_t< T, N > &c)
Definition: functors.h:303
owl::common::arg_min
__both__ int arg_min(const vec_t< T, N > &v)
Definition: functors.h:319
owl::common::clamp
__both__ LinearSpace3< T > clamp(const LinearSpace3< T > &space)
Definition: LinearSpace.h:346
_define_binary_functor
#define _define_binary_functor(fct)
owl::common::vec_t< T, 3 >::y
T y
Definition: vec.h:194
owl::common::vec_t< T, 2 >::y
T y
Definition: vec.h:133
owl::common::vec_t< T, 2 >
Definition: vec.h:96
owl::common::abs
__both__ T abs(const QuaternionT< T > &a)
Definition: Quaternion.h:101
owl::common::saturate
__both__ float saturate(const float &f)
Definition: owl-common.h:160
owl::common::lt
__both__ auto lt(const vec_t< T, 2 > &a, const vec_t< T, 2 > &b) -> vec_t< decltype(a.x< b.x), 2 >
Definition: compare.h:117
owl::common::_define_float_functor
_define_float_functor(rcp) _define_float_functor(sin) _define_float_functor(cos) _define_float_functor(abs) _define_float_functor(saturate) _define_binary_functor(divRoundUp) _define_binary_functor(min) _define_binary_functor(max) _define_operator(*)
owl::common::any_less_than
__both__ bool any_less_than(const vec_t< T, N > &a, const vec_t< T, N > &b)
Definition: functors.h:29
owl::common::all
__both__ bool all(const vec_t< T, N > &a)
Definition: compare.h:167
owl::common::ge
__both__ auto ge(const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(nt(lt(a, b)))
Definition: compare.h:154
owl::common::vec_t< T, 1 >
Definition: vec.h:57
owl::common::vec_t< T, 1 >::x
T x
just to allow all vec types to use x,y,z,w,...
Definition: vec.h:88
owl::common::operator-
AffineSpaceT< L > operator-(const AffineSpaceT< L > &a)
Definition: AffineSpace.h:116
owl::common::randomColor
__both__ vec3f randomColor(int i)
Definition: functors.h:343
owl::common::divRoundUp
__both__ int32_t divRoundUp(int32_t a, int32_t b)
Definition: owl-common.h:168
owl::common::vec_t< T, 4 >::w
T w
Definition: vec.h:282
owl::common::reduce_max
__both__ T reduce_max(const vec_t< T, 2 > &v)
Definition: functors.h:295
owl::common::vec_t< T, 4 >::x
T x
Definition: vec.h:282
owl::common::vec_t
Definition: vec.h:33
owl::common::vec_t< T, 3 >
Definition: vec.h:143
owl::common::all_less_than
__both__ bool all_less_than(const vec_t< T, N > &a, const vec_t< T, N > &b)
Definition: functors.h:33
owl::common::vec_t< T, 4 >::y
T y
Definition: vec.h:282
owl::common::gt
__both__ auto gt(const vec_t< T, N > &a, const vec_t< T, N > &b) -> decltype(lt(b, a))
Definition: compare.h:145
owl::common::operator<
__both__ bool operator<(const vec_t< T, 3 > &a, const vec_t< T, 3 > &b)
Definition: functors.h:330
owl::common::_define_op_assign_operator
_define_op_assign_operator(operator*=, *=)
owl::common::operator+
AffineSpaceT< L > operator+(const AffineSpaceT< L > &a)
Definition: AffineSpace.h:117
owl::common::any_greater_or_equal
__both__ bool any_greater_or_equal(const vec_t< T, N > &a, const vec_t< T, N > &b)
Definition: functors.h:43
owl::common::rcp
AffineSpaceT< L > rcp(const AffineSpaceT< L > &a)
Definition: AffineSpace.h:118
owl
Definition: APIContext.cpp:36
owl::common::any_greater_than
__both__ bool any_greater_than(const vec_t< T, N > &a, const vec_t< T, N > &b)
Definition: functors.h:37
owl::common::vec_t< T, 3 >::x
T x
Definition: vec.h:194
owl::common::arg_max
__both__ int arg_max(const vec_t< T, N > &v)
Definition: functors.h:310
owl::common::vec_t< T, 2 >::x
T x
Definition: vec.h:133
__both__
#define __both__
Definition: owl-common.h:102
owl::common::vec_t< T, 4 >
Definition: vec.h:228
owl::common::any
__both__ bool any(const vec_t< T, N > &a)
Definition: compare.h:163