Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
godotengine
GitHub Repository: godotengine/godot
 Path: blob/master/thirdparty/embree/common/math/math_sycl.h
9912 views
1
// Copyright 2009-2021 Intel Corporation

2
// SPDX-License-Identifier: Apache-2.0

3


4
#pragma once

5


6
#include "../sys/platform.h"

7
#include "../sys/intrinsics.h"

8
#include "constants.h"

9
#include <cmath>

10


11
namespace embree

12
{

13
  __forceinline bool isvalid ( const float& v ) {

14
    return (v > -FLT_LARGE) & (v < +FLT_LARGE);

15
  }

16


17
  __forceinline int cast_f2i(float f) {

18
    return __builtin_bit_cast(int,f);

19
  }

20


21
  __forceinline float cast_i2f(int i) {

22
    return __builtin_bit_cast(float,i);

23
  }

24


25
  __forceinline int   toInt  (const float& a) { return int(a); }

26
  __forceinline float toFloat(const int&   a) { return float(a); }

27


28
  __forceinline float asFloat(const int   a) { return __builtin_bit_cast(float,a); }

29
  __forceinline int   asInt  (const float a) { return __builtin_bit_cast(int,a); }

30
  

31
  //__forceinline bool finite ( const float x ) { return _finite(x) != 0; }

32
  __forceinline float sign ( const float x ) { return x<0?-1.0f:1.0f; }

33
  __forceinline float sqr  ( const float x ) { return x*x; }

34


35
  __forceinline float rcp  ( const float x ) {

36
    return sycl::native::recip(x);

37
  }

38


39
  __forceinline float signmsk(const float a) { return asFloat(asInt(a) & 0x80000000); }

40
  //__forceinline float signmsk ( const float x ) {

41
  //  return _mm_cvtss_f32(_mm_and_ps(_mm_set_ss(x),_mm_castsi128_ps(_mm_set1_epi32(0x80000000))));

42
  //}

43
  //__forceinline float xorf( const float x, const float y ) {

44
  //  return _mm_cvtss_f32(_mm_xor_ps(_mm_set_ss(x),_mm_set_ss(y)));

45
  //}

46
  //__forceinline float andf( const float x, const unsigned y ) {

47
  //  return _mm_cvtss_f32(_mm_and_ps(_mm_set_ss(x),_mm_castsi128_ps(_mm_set1_epi32(y))));

48
  //}

49
  

50
  __forceinline float rsqrt( const float x ) {

51
    return sycl::rsqrt(x);

52
  }

53


54
  //__forceinline float nextafter(float x, float y) { if ((x<y) == (x>0)) return x*(1.1f+float(ulp)); else return x*(0.9f-float(ulp)); }

55
  //__forceinline double nextafter(double x, double y) { return _nextafter(x, y); }

56
  //__forceinline int roundf(float f) { return (int)(f + 0.5f); }

57


58
  __forceinline float abs  ( const float x ) { return sycl::fabs(x); }

59
  __forceinline float acos ( const float x ) { return sycl::acos(x); }

60
  __forceinline float asin ( const float x ) { return sycl::asin(x); }

61
  __forceinline float atan ( const float x ) { return sycl::atan(x); }

62
  __forceinline float atan2( const float y, const float x ) { return sycl::atan2(y, x); }

63
  __forceinline float cos  ( const float x ) { return sycl::cos(x); }

64
  __forceinline float cosh ( const float x ) { return sycl::cosh(x); }

65
  __forceinline float exp  ( const float x ) { return sycl::exp(x); }

66
  __forceinline float fmod ( const float x, const float y ) { return sycl::fmod(x, y); }

67
  __forceinline float log  ( const float x ) { return sycl::log(x); }

68
  __forceinline float log10( const float x ) { return sycl::log10(x); }

69
  __forceinline float pow  ( const float x, const float y ) { return sycl::pow(x, y); }

70
  __forceinline float sin  ( const float x ) { return sycl::sin(x); }

71
  __forceinline float sinh ( const float x ) { return sycl::sinh(x); }

72
  __forceinline float sqrt ( const float x ) { return sycl::sqrt(x); }

73
  __forceinline float tan  ( const float x ) { return sycl::tan(x); }

74
  __forceinline float tanh ( const float x ) { return sycl::tanh(x); }

75
  __forceinline float floor( const float x ) { return sycl::floor(x); }

76
  __forceinline float ceil ( const float x ) { return sycl::ceil(x); }

77
  __forceinline float frac ( const float x ) { return x-floor(x); }

78


79
  //__forceinline double abs  ( const double x ) { return ::fabs(x); }

80
  //__forceinline double sign ( const double x ) { return x<0?-1.0:1.0; }

81
  //__forceinline double acos ( const double x ) { return ::acos (x); }

82
  //__forceinline double asin ( const double x ) { return ::asin (x); }

83
  //__forceinline double atan ( const double x ) { return ::atan (x); }

84
  //__forceinline double atan2( const double y, const double x ) { return ::atan2(y, x); }

85
  //__forceinline double cos  ( const double x ) { return ::cos  (x); }

86
  //__forceinline double cosh ( const double x ) { return ::cosh (x); }

87
  //__forceinline double exp  ( const double x ) { return ::exp  (x); }

88
  //__forceinline double fmod ( const double x, const double y ) { return ::fmod (x, y); }

89
  //__forceinline double log  ( const double x ) { return ::log  (x); }

90
  //__forceinline double log10( const double x ) { return ::log10(x); }

91
  //__forceinline double pow  ( const double x, const double y ) { return ::pow  (x, y); }

92
  //__forceinline double rcp  ( const double x ) { return 1.0/x; }

93
  //__forceinline double rsqrt( const double x ) { return 1.0/::sqrt(x); }

94
  //__forceinline double sin  ( const double x ) { return ::sin  (x); }

95
  //__forceinline double sinh ( const double x ) { return ::sinh (x); }

96
  //__forceinline double sqr  ( const double x ) { return x*x; }

97
  //__forceinline double sqrt ( const double x ) { return ::sqrt (x); }

98
  //__forceinline double tan  ( const double x ) { return ::tan  (x); }

99
  //__forceinline double tanh ( const double x ) { return ::tanh (x); }

100
  //__forceinline double floor( const double x ) { return ::floor (x); }

101
  //__forceinline double ceil ( const double x ) { return ::ceil (x); }

102


103
/*

104
#if defined(__SSE4_1__)

105
  __forceinline float mini(float a, float b) {

106
    const __m128i ai = _mm_castps_si128(_mm_set_ss(a));

107
    const __m128i bi = _mm_castps_si128(_mm_set_ss(b));

108
    const __m128i ci = _mm_min_epi32(ai,bi);

109
    return _mm_cvtss_f32(_mm_castsi128_ps(ci));

110
  }

111
#endif

112


113
#if defined(__SSE4_1__)

114
  __forceinline float maxi(float a, float b) {

115
    const __m128i ai = _mm_castps_si128(_mm_set_ss(a));

116
    const __m128i bi = _mm_castps_si128(_mm_set_ss(b));

117
    const __m128i ci = _mm_max_epi32(ai,bi);

118
    return _mm_cvtss_f32(_mm_castsi128_ps(ci));

119
  }

120
#endif

121
*/

122
  

123
  template<typename T>

124
    __forceinline T twice(const T& a) { return a+a; }

125


126
  __forceinline      int min(int      a, int      b) { return sycl::min(a,b); }

127
  __forceinline unsigned min(unsigned a, unsigned b) { return sycl::min(a,b); }

128
  __forceinline  int64_t min(int64_t  a, int64_t  b) { return sycl::min(a,b); }

129
  __forceinline    float min(float    a, float    b) { return sycl::fmin(a,b); }

130
  __forceinline   double min(double   a, double   b) { return sycl::fmin(a,b); }

131
#if defined(__X86_64__)

132
  __forceinline   size_t min(size_t   a, size_t   b) { return sycl::min(a,b); }

133
#endif

134


135
  template<typename T> __forceinline T min(const T& a, const T& b, const T& c) { return min(min(a,b),c); }

136
  template<typename T> __forceinline T min(const T& a, const T& b, const T& c, const T& d) { return min(min(a,b),min(c,d)); }

137
  template<typename T> __forceinline T min(const T& a, const T& b, const T& c, const T& d, const T& e) { return min(min(min(a,b),min(c,d)),e); }

138


139
//  template<typename T> __forceinline T mini(const T& a, const T& b, const T& c) { return mini(mini(a,b),c); }

140
//  template<typename T> __forceinline T mini(const T& a, const T& b, const T& c, const T& d) { return mini(mini(a,b),mini(c,d)); }

141
//  template<typename T> __forceinline T mini(const T& a, const T& b, const T& c, const T& d, const T& e) { return mini(mini(mini(a,b),mini(c,d)),e); }

142


143
  __forceinline      int max(int      a, int      b) { return sycl::max(a,b); }

144
  __forceinline unsigned max(unsigned a, unsigned b) { return sycl::max(a,b); }

145
  __forceinline  int64_t max(int64_t  a, int64_t  b) { return sycl::max(a,b); }

146
  __forceinline    float max(float    a, float    b) { return sycl::fmax(a,b); }

147
  __forceinline   double max(double   a, double   b) { return sycl::fmax(a,b); }

148
#if defined(__X86_64__)

149
  __forceinline   size_t max(size_t   a, size_t   b) { return sycl::max(a,b); }

150
#endif

151


152
  template<typename T> __forceinline T max(const T& a, const T& b, const T& c) { return max(max(a,b),c); }

153
  template<typename T> __forceinline T max(const T& a, const T& b, const T& c, const T& d) { return max(max(a,b),max(c,d)); }

154
  template<typename T> __forceinline T max(const T& a, const T& b, const T& c, const T& d, const T& e) { return max(max(max(a,b),max(c,d)),e); }

155


156
//  template<typename T> __forceinline T maxi(const T& a, const T& b, const T& c) { return maxi(maxi(a,b),c); }

157
//  template<typename T> __forceinline T maxi(const T& a, const T& b, const T& c, const T& d) { return maxi(maxi(a,b),maxi(c,d)); }

158
//  template<typename T> __forceinline T maxi(const T& a, const T& b, const T& c, const T& d, const T& e) { return maxi(maxi(maxi(a,b),maxi(c,d)),e); }

159


160
  template<typename T> __forceinline T clamp(const T& x, const T& lower = T(zero), const T& upper = T(one)) { return max(min(x,upper),lower); }

161
  template<typename T> __forceinline T clampz(const T& x, const T& upper) { return max(T(zero), min(x,upper)); }

162


163
  template<typename T> __forceinline T  deg2rad ( const T& x )  { return x * T(1.74532925199432957692e-2f); }

164
  template<typename T> __forceinline T  rad2deg ( const T& x )  { return x * T(5.72957795130823208768e1f); }

165
  template<typename T> __forceinline T  sin2cos ( const T& x )  { return sqrt(max(T(zero),T(one)-x*x)); }

166
  template<typename T> __forceinline T  cos2sin ( const T& x )  { return sin2cos(x); }

167


168
  __forceinline float madd  ( const float a, const float b, const float c) { return +sycl::fma(+a,b,+c); }

169
  __forceinline float msub  ( const float a, const float b, const float c) { return +sycl::fma(+a,b,-c); }

170
  __forceinline float nmadd ( const float a, const float b, const float c) { return +sycl::fma(-a,b,+c); }

171
  __forceinline float nmsub ( const float a, const float b, const float c) { return -sycl::fma(+a,b,+c); }

172


173
  /*! random functions */

174
/*

175
  template<typename T> T random() { return T(0); }

176
  template<> __forceinline int      random() { return int(rand()); }

177
  template<> __forceinline uint32_t random() { return uint32_t(rand()) ^ (uint32_t(rand()) << 16); }

178
  template<> __forceinline float  random() { return rand()/float(RAND_MAX); }

179
  template<> __forceinline double random() { return rand()/double(RAND_MAX); }

180
*/

181
  

182
  /*! selects */

183
  __forceinline bool  select(bool s, bool  t , bool f) { return s ? t : f; }

184
  __forceinline int   select(bool s, int   t,   int f) { return s ? t : f; }

185
  __forceinline float select(bool s, float t, float f) { return s ? t : f; }

186


187
  __forceinline bool none(bool s) { return !s; }

188
  __forceinline bool all (bool s) { return s; }

189
  __forceinline bool any (bool s) { return s; }

190


191
  __forceinline unsigned movemask (bool s) { return (unsigned)s; }

192


193
  __forceinline float lerp(const float v0, const float v1, const float t) {

194
    return madd(1.0f-t,v0,t*v1);

195
  }

196


197
  template<typename T>

198
    __forceinline T lerp2(const float x0, const float x1, const float x2, const float x3, const T& u, const T& v) {

199
    return madd((1.0f-u),madd((1.0f-v),T(x0),v*T(x2)),u*madd((1.0f-v),T(x1),v*T(x3)));

200
  }

201


202
  /*! exchange */

203
  template<typename T> __forceinline void xchg ( T& a, T& b ) { const T tmp = a; a = b; b = tmp; }

204


205
   /*  load/store */

206
  template<typename Ty> struct mem;

207
 

208
  template<> struct mem<float> {

209
    static __forceinline float load (bool mask, const void* ptr) { return mask ? *(float*)ptr : 0.0f; }

210
    static __forceinline float loadu(bool mask, const void* ptr) { return mask ? *(float*)ptr : 0.0f; }

211
  

212
    static __forceinline void store (bool mask, void* ptr, const float v) { if (mask) *(float*)ptr = v; }

213
    static __forceinline void storeu(bool mask, void* ptr, const float v) { if (mask) *(float*)ptr = v; }

214
  };

215
  

216
  /*! bit reverse operation */

217
  template<class T>

218
    __forceinline T bitReverse(const T& vin)

219
  {

220
    T v = vin;

221
    v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);

222
    v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);

223
    v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);

224
    v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);

225
    v = ( v >> 16             ) | ( v               << 16);

226
    return v;

227
  }

228


229
  /*! bit interleave operation */

230
  template<class T>

231
    __forceinline T bitInterleave(const T& xin, const T& yin, const T& zin)

232
  {

233
	T x = xin, y = yin, z = zin;

234
    x = (x | (x << 16)) & 0x030000FF;

235
    x = (x | (x <<  8)) & 0x0300F00F;

236
    x = (x | (x <<  4)) & 0x030C30C3;

237
    x = (x | (x <<  2)) & 0x09249249;

238


239
    y = (y | (y << 16)) & 0x030000FF;

240
    y = (y | (y <<  8)) & 0x0300F00F;

241
    y = (y | (y <<  4)) & 0x030C30C3;

242
    y = (y | (y <<  2)) & 0x09249249;

243


244
    z = (z | (z << 16)) & 0x030000FF;

245
    z = (z | (z <<  8)) & 0x0300F00F;

246
    z = (z | (z <<  4)) & 0x030C30C3;

247
    z = (z | (z <<  2)) & 0x09249249;

248


249
    return x | (y << 1) | (z << 2);

250
  }

251


252
  /*! bit interleave operation for 64bit data types*/

253
  template<class T>

254
    __forceinline T bitInterleave64(const T& xin, const T& yin, const T& zin){

255
    T x = xin & 0x1fffff;

256
    T y = yin & 0x1fffff;

257
    T z = zin & 0x1fffff;

258


259
    x = (x | x << 32) & 0x1f00000000ffff;

260
    x = (x | x << 16) & 0x1f0000ff0000ff;

261
    x = (x | x << 8) & 0x100f00f00f00f00f;

262
    x = (x | x << 4) & 0x10c30c30c30c30c3;

263
    x = (x | x << 2) & 0x1249249249249249;

264


265
    y = (y | y << 32) & 0x1f00000000ffff;

266
    y = (y | y << 16) & 0x1f0000ff0000ff;

267
    y = (y | y << 8) & 0x100f00f00f00f00f;

268
    y = (y | y << 4) & 0x10c30c30c30c30c3;

269
    y = (y | y << 2) & 0x1249249249249249;

270


271
    z = (z | z << 32) & 0x1f00000000ffff;

272
    z = (z | z << 16) & 0x1f0000ff0000ff;

273
    z = (z | z << 8) & 0x100f00f00f00f00f;

274
    z = (z | z << 4) & 0x10c30c30c30c30c3;

275
    z = (z | z << 2) & 0x1249249249249249;

276


277
    return x | (y << 1) | (z << 2);

278
  }

279
}

280


281