OWL
OptiX7 Wrapper Library
owl-common.h
Go to the documentation of this file.
1 // ======================================================================== //
2 // Copyright 2018-2020 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 #ifndef _USE_MATH_DEFINES
20 # define _USE_MATH_DEFINES
21 #endif
22 #include <math.h> // using cmath causes issues under Windows
23 
24 #include <stdio.h>
25 #include <iostream>
26 #include <stdexcept>
27 #include <memory>
28 #include <assert.h>
29 #include <string>
30 #include <math.h>
31 #include <cmath>
32 #include <algorithm>
33 #ifdef __GNUC__
34 #include <sys/time.h>
35 #endif
36 
37 #ifdef _WIN32
38 #ifndef WIN32_LEAN_AND_MEAN
39 #define WIN32_LEAN_AND_MEAN
40 #endif
41 #include <Windows.h>
42 #ifdef min
43 #undef min
44 #endif
45 #ifdef max
46 #undef max
47 #endif
48 #endif
49 
50 
51 #if defined(_MSC_VER)
52 # define OWL_DLL_EXPORT __declspec(dllexport)
53 # define OWL_DLL_IMPORT __declspec(dllimport)
54 #elif defined(__clang__) || defined(__GNUC__)
55 # define OWL_DLL_EXPORT __attribute__((visibility("default")))
56 # define OWL_DLL_IMPORT __attribute__((visibility("default")))
57 #else
58 # define OWL_DLL_EXPORT
59 # define OWL_DLL_IMPORT
60 #endif
61 
62 // #if 1
63 # define OWL_INTERFACE /* nothing - currently not building any special 'owl.dll' */
64 // #else
65 // //#if defined(OWL_DLL_INTERFACE)
66 // # ifdef owl_EXPORTS
67 // # define OWL_INTERFACE OWL_DLL_EXPORT
68 // # else
69 // # define OWL_INTERFACE OWL_DLL_IMPORT
70 // # endif
71 // //#else
72 // //# define OWL_INTERFACE /*static lib*/
73 // //#endif
74 // #endif
75 
76 //#ifdef __WIN32__
77 //#define __PRETTY_FUNCTION__ __FUNCTION__
78 //#endif
79 #if defined(_MSC_VER)
80 //&& !defined(__PRETTY_FUNCTION__)
81 # define __PRETTY_FUNCTION__ __FUNCTION__
82 #endif
83 
84 
85 #ifndef PRINT
86 # define PRINT(var) std::cout << #var << "=" << var << std::endl;
87 #ifdef __WIN32__
88 # define PING std::cout << __FILE__ << "::" << __LINE__ << ": " << __FUNCTION__ << std::endl;
89 #else
90 # define PING std::cout << __FILE__ << "::" << __LINE__ << ": " << __PRETTY_FUNCTION__ << std::endl;
91 #endif
92 #endif
93 
94 #if defined(__CUDA_ARCH__)
95 # define __owl_device __device__
96 # define __owl_host __host__
97 #else
98 # define __owl_device /* ignore */
99 # define __owl_host /* ignore */
100 #endif
101 
102 # define __both__ __owl_host __owl_device
103 
104 
105 #ifdef __GNUC__
106 #define MAYBE_UNUSED __attribute__((unused))
107 #else
108 #define MAYBE_UNUSED
109 #endif
110 
111 
112 
113 
114 #define OWL_NOTIMPLEMENTED throw std::runtime_error(std::string(__PRETTY_FUNCTION__)+" not implemented")
115 
116 #define OWL_TERMINAL_RED "\033[0;31m"
117 #define OWL_TERMINAL_GREEN "\033[0;32m"
118 #define OWL_TERMINAL_LIGHT_GREEN "\033[1;32m"
119 #define OWL_TERMINAL_YELLOW "\033[1;33m"
120 #define OWL_TERMINAL_BLUE "\033[0;34m"
121 #define OWL_TERMINAL_LIGHT_BLUE "\033[1;34m"
122 #define OWL_TERMINAL_RESET "\033[0m"
123 #define OWL_TERMINAL_DEFAULT OWL_TERMINAL_RESET
124 #define OWL_TERMINAL_BOLD "\033[1;1m"
125 
126 #define OWL_TERMINAL_MAGENTA "\e[35m"
127 #define OWL_TERMINAL_LIGHT_MAGENTA "\e[95m"
128 #define OWL_TERMINAL_CYAN "\e[36m"
129 //#define OWL_TERMINAL_LIGHT_RED "\e[91m"
130 #define OWL_TERMINAL_LIGHT_RED "\033[1;31m"
131 
132 #ifdef _MSC_VER
133 # define OWL_ALIGN(alignment) __declspec(align(alignment))
134 #else
135 # define OWL_ALIGN(alignment) __attribute__((aligned(alignment)))
136 #endif
137 
138 
139 
140 namespace owl {
141  namespace common {
142 
143 #ifdef __CUDA_ARCH__
144  using ::min;
145  using ::max;
146  // inline __both__ float abs(float f) { return fabsf(f); }
147  // inline __both__ double abs(double f) { return fabs(f); }
148  using std::abs;
149  // inline __both__ float sin(float f) { return ::sinf(f); }
150  // inline __both__ double sin(double f) { return ::sin(f); }
151  // inline __both__ float cos(float f) { return ::cosf(f); }
152  // inline __both__ double cos(double f) { return ::cos(f); }
153 
154  using ::saturate;
155 #else
156  using std::min;
157  using std::max;
158  using std::abs;
159  // inline __both__ double sin(double f) { return ::sin(f); }
160  inline __both__ float saturate(const float &f) { return min(1.f,max(0.f,f)); }
161 #endif
162 
163  // inline __both__ float abs(float f) { return fabsf(f); }
164  // inline __both__ double abs(double f) { return fabs(f); }
165  inline __both__ float rcp(float f) { return 1.f/f; }
166  inline __both__ double rcp(double d) { return 1./d; }
167 
168  inline __both__ int32_t divRoundUp(int32_t a, int32_t b) { return (a+b-1)/b; }
169  inline __both__ uint32_t divRoundUp(uint32_t a, uint32_t b) { return (a+b-1)/b; }
170  inline __both__ int64_t divRoundUp(int64_t a, int64_t b) { return (a+b-1)/b; }
171  inline __both__ uint64_t divRoundUp(uint64_t a, uint64_t b) { return (a+b-1)/b; }
172 
173 // #ifdef __CUDA_ARCH__
174 // using ::sin; // this is the double version
175 // // inline __both__ float sin(float f) { return ::sinf(f); }
176 // using ::cos; // this is the double version
177 // // inline __both__ float cos(float f) { return ::cosf(f); }
178 // #else
179  using ::sin; // this is the double version
180  using ::cos; // this is the double version
181 // #endif
182 
189  namespace polymorphic {
190 #ifdef __CUDA_ARCH__
191  inline __both__ float sqrt(const float f) { return ::sqrtf(f); }
192  inline __both__ double sqrt(const double d) { return ::sqrt(d); }
193 #else
194  inline __both__ float sqrt(const float f) { return ::sqrtf(f); }
195  inline __both__ double sqrt(const double d) { return ::sqrt(d); }
196 #endif
197 
198  inline __both__ float rsqrt(const float f) { return 1.f/owl::common::polymorphic::sqrt(f); }
199  inline __both__ double rsqrt(const double d) { return 1./owl::common::polymorphic::sqrt(d); }
200  }
201 
202 
203 #ifdef __WIN32__
204 # define osp_snprintf sprintf_s
205 #else
206 # define osp_snprintf snprintf
207 #endif
208 
210  inline std::string prettyDouble(const double val) {
211  const double absVal = abs(val);
212  char result[1000];
213 
214  if (absVal >= 1e+18f) osp_snprintf(result,1000,"%.1f%c",float(val/1e18f),'E');
215  else if (absVal >= 1e+15f) osp_snprintf(result,1000,"%.1f%c",float(val/1e15f),'P');
216  else if (absVal >= 1e+12f) osp_snprintf(result,1000,"%.1f%c",float(val/1e12f),'T');
217  else if (absVal >= 1e+09f) osp_snprintf(result,1000,"%.1f%c",float(val/1e09f),'G');
218  else if (absVal >= 1e+06f) osp_snprintf(result,1000,"%.1f%c",float(val/1e06f),'M');
219  else if (absVal >= 1e+03f) osp_snprintf(result,1000,"%.1f%c",float(val/1e03f),'k');
220  else if (absVal <= 1e-12f) osp_snprintf(result,1000,"%.1f%c",float(val*1e15f),'f');
221  else if (absVal <= 1e-09f) osp_snprintf(result,1000,"%.1f%c",float(val*1e12f),'p');
222  else if (absVal <= 1e-06f) osp_snprintf(result,1000,"%.1f%c",float(val*1e09f),'n');
223  else if (absVal <= 1e-03f) osp_snprintf(result,1000,"%.1f%c",float(val*1e06f),'u');
224  else if (absVal <= 1e-00f) osp_snprintf(result,1000,"%.1f%c",float(val*1e03f),'m');
225  else osp_snprintf(result,1000,"%f",(float)val);
226 
227  return result;
228  }
229 
230 
231 
232  inline std::string prettyNumber(const size_t s)
233  {
234  char buf[1000];
235  if (s >= (1024LL*1024LL*1024LL*1024LL)) {
236  osp_snprintf(buf, 1000,"%.2fT",s/(1024.f*1024.f*1024.f*1024.f));
237  } else if (s >= (1024LL*1024LL*1024LL)) {
238  osp_snprintf(buf, 1000, "%.2fG",s/(1024.f*1024.f*1024.f));
239  } else if (s >= (1024LL*1024LL)) {
240  osp_snprintf(buf, 1000, "%.2fM",s/(1024.f*1024.f));
241  } else if (s >= (1024LL)) {
242  osp_snprintf(buf, 1000, "%.2fK",s/(1024.f));
243  } else {
244  osp_snprintf(buf,1000,"%zi",s);
245  }
246  return buf;
247  }
248 
249  inline double getCurrentTime()
250  {
251 #ifdef _WIN32
252  SYSTEMTIME tp; GetSystemTime(&tp);
253  /*
254  Please note: we are not handling the "leap year" issue.
255  */
256  size_t numSecsSince2020
257  = tp.wSecond
258  + (60ull) * tp.wMinute
259  + (60ull * 60ull) * tp.wHour
260  + (60ull * 60ul * 24ull) * tp.wDay
261  + (60ull * 60ul * 24ull * 365ull) * (tp.wYear - 2020);
262  return double(numSecsSince2020 + tp.wMilliseconds * 1e-3);
263 #else
264  struct timeval tp; gettimeofday(&tp,nullptr);
265  return double(tp.tv_sec) + double(tp.tv_usec)/1E6;
266 #endif
267  }
268 
269  inline bool hasSuffix(const std::string &s, const std::string &suffix)
270  {
271  return s.substr(s.size()-suffix.size()) == suffix;
272  }
273 
274  } // ::owl::common
275 } // ::owl
owl::common::hasSuffix
bool hasSuffix(const std::string &s, const std::string &suffix)
Definition: owl-common.h:269
owl::common::prettyDouble
std::string prettyDouble(const double val)
Definition: owl-common.h:210
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::divRoundUp
__both__ int32_t divRoundUp(int32_t a, int32_t b)
Definition: owl-common.h:168
owl::common::prettyNumber
std::string prettyNumber(const size_t s)
Definition: owl-common.h:232
owl::common::getCurrentTime
double getCurrentTime()
Definition: owl-common.h:249
owl::common::polymorphic::sqrt
__both__ float sqrt(const float f)
Definition: owl-common.h:194
owl::common::polymorphic::rsqrt
__both__ float rsqrt(const float f)
Definition: owl-common.h:198
osp_snprintf
#define osp_snprintf
Definition: owl-common.h:206
owl::common::rcp
AffineSpaceT< L > rcp(const AffineSpaceT< L > &a)
Definition: AffineSpace.h:118
owl
Definition: APIContext.cpp:36
owl::common::polymorphic::sqrt
__both__ double sqrt(const double d)
Definition: owl-common.h:195
__both__
#define __both__
Definition: owl-common.h:102