Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
godotengine
GitHub Repository: godotengine/godot
 Path: blob/master/thirdparty/embree/common/math/vec2fa_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/alloc.h"

7
#include "emath.h"

8
#include "../simd/sse.h"

9


10
namespace embree

11
{

12
  struct Vec3fa;

13
  

14
  ////////////////////////////////////////////////////////////////////////////////

15
  /// SSE Vec2fa Type

16
  ////////////////////////////////////////////////////////////////////////////////

17


18
  struct __aligned(16) Vec2fa

19
  {

20
    //ALIGNED_STRUCT_(16);

21


22
    typedef float Scalar;

23
    enum { N = 2 };

24
    struct { float x,y; };

25
    

26
    ////////////////////////////////////////////////////////////////////////////////

27
    /// Constructors, Assignment & Cast Operators

28
    ////////////////////////////////////////////////////////////////////////////////

29


30
    __forceinline Vec2fa( ) {}

31
    //__forceinline Vec2fa( const __m128 a ) : m128(a) {}

32
    explicit Vec2fa(const Vec3fa& a);

33
    

34
    __forceinline explicit Vec2fa( const vfloat<4>& a ) {

35
      x = a[0];

36
      y = a[1];

37
    }

38


39
    __forceinline Vec2fa            ( const Vec2<float>& other  ) { x = other.x; y = other.y; }

40
    __forceinline Vec2fa& operator =( const Vec2<float>& other ) { x = other.x; y = other.y; return *this; }

41


42
    __forceinline Vec2fa            ( const Vec2fa& other ) { x = other.x; y = other.y; }

43
    __forceinline Vec2fa& operator =( const Vec2fa& other ) { x = other.x; y = other.y; return *this; }

44


45
    __forceinline explicit Vec2fa( const float a ) : x(a), y(a) {}

46
    __forceinline          Vec2fa( const float x, const float y) : x(x), y(y) {}

47


48
    //__forceinline explicit Vec2fa( const __m128i a ) : m128(_mm_cvtepi32_ps(a)) {}

49


50
    //__forceinline operator const __m128&() const { return m128; }

51
    //__forceinline operator       __m128&()       { return m128; }

52


53
    ////////////////////////////////////////////////////////////////////////////////

54
    /// Loads and Stores

55
    ////////////////////////////////////////////////////////////////////////////////

56


57
    static __forceinline Vec2fa load( const void* const a ) {

58
      const float* ptr = (const float*)a;

59
      return Vec2fa(ptr[0],ptr[1]);

60
    }

61


62
    static __forceinline Vec2fa loadu( const void* const a ) {

63
      const float* ptr = (const float*)a;

64
      return Vec2fa(ptr[0],ptr[1]);

65
    }

66


67
    static __forceinline void storeu ( void* a, const Vec2fa& v ) {

68
      float* ptr = (float*)a;

69
      ptr[0] = v.x; ptr[1] = v.y;

70
    }

71


72
    ////////////////////////////////////////////////////////////////////////////////

73
    /// Constants

74
    ////////////////////////////////////////////////////////////////////////////////

75


76
    __forceinline Vec2fa( ZeroTy   ) : x(0.0f), y(0.0f) {}

77
    __forceinline Vec2fa( OneTy    ) : x(1.0f), y(1.0f) {}

78
    __forceinline Vec2fa( PosInfTy ) : x(+INFINITY), y(+INFINITY) {}

79
    __forceinline Vec2fa( NegInfTy ) : x(-INFINITY), y(-INFINITY) {}

80


81
    ////////////////////////////////////////////////////////////////////////////////

82
    /// Array Access

83
    ////////////////////////////////////////////////////////////////////////////////

84


85
    //__forceinline const float& operator []( const size_t index ) const { assert(index < 2); return (&x)[index]; }

86
    //__forceinline       float& operator []( const size_t index )       { assert(index < 2); return (&x)[index]; }

87
  };

88


89
  ////////////////////////////////////////////////////////////////////////////////

90
  /// Unary Operators

91
  ////////////////////////////////////////////////////////////////////////////////

92


93
  __forceinline Vec2fa operator +( const Vec2fa& a ) { return a; }

94
  __forceinline Vec2fa operator -( const Vec2fa& a ) { return Vec2fa(-a.x,-a.y); }

95
  __forceinline Vec2fa abs  ( const Vec2fa& a ) { return Vec2fa(sycl::fabs(a.x),sycl::fabs(a.y)); }

96
  __forceinline Vec2fa sign ( const Vec2fa& a ) { return Vec2fa(sycl::sign(a.x),sycl::sign(a.y)); }

97


98
   //__forceinline Vec2fa rcp  ( const Vec2fa& a ) { return Vec2fa(sycl::native::recip(a.x),sycl::native::recip(a.y)); }

99
  __forceinline Vec2fa rcp  ( const Vec2fa& a ) { return Vec2fa(sycl::native::recip(a.x),sycl::native::recip(a.y)); }

100
  __forceinline Vec2fa sqrt ( const Vec2fa& a ) { return Vec2fa(sycl::sqrt(a.x),sycl::sqrt(a.y)); }

101
  __forceinline Vec2fa sqr  ( const Vec2fa& a ) { return Vec2fa(a.x*a.x,a.y*a.y); }

102
  

103
  __forceinline Vec2fa rsqrt( const Vec2fa& a ) { return Vec2fa(sycl::rsqrt(a.x),sycl::rsqrt(a.y)); }

104


105
  __forceinline Vec2fa zero_fix(const Vec2fa& a) {

106
    const float x = sycl::fabs(a.x) < min_rcp_input ? min_rcp_input : a.x;

107
    const float y = sycl::fabs(a.y) < min_rcp_input ? min_rcp_input : a.y;

108
    return Vec2fa(x,y);

109
  }

110
  __forceinline Vec2fa rcp_safe(const Vec2fa& a) {

111
    return rcp(zero_fix(a));

112
  }

113
  __forceinline Vec2fa log ( const Vec2fa& a ) {

114
    return Vec2fa(sycl::log(a.x),sycl::log(a.y));

115
  }

116


117
  __forceinline Vec2fa exp ( const Vec2fa& a ) {

118
    return Vec2fa(sycl::exp(a.x),sycl::exp(a.y));

119
  }

120


121
  ////////////////////////////////////////////////////////////////////////////////

122
  /// Binary Operators

123
  ////////////////////////////////////////////////////////////////////////////////

124


125
  __forceinline Vec2fa operator +( const Vec2fa& a, const Vec2fa& b ) { return Vec2fa(a.x+b.x, a.y+b.y); }

126
  __forceinline Vec2fa operator -( const Vec2fa& a, const Vec2fa& b ) { return Vec2fa(a.x-b.x, a.y-b.y); }

127
  __forceinline Vec2fa operator *( const Vec2fa& a, const Vec2fa& b ) { return Vec2fa(a.x*b.x, a.y*b.y); }

128
  __forceinline Vec2fa operator *( const Vec2fa& a, const float b ) { return a * Vec2fa(b); }

129
  __forceinline Vec2fa operator *( const float a, const Vec2fa& b ) { return Vec2fa(a) * b; }

130
  __forceinline Vec2fa operator /( const Vec2fa& a, const Vec2fa& b ) { return Vec2fa(a.x/b.x, a.y/b.y); }

131
  __forceinline Vec2fa operator /( const Vec2fa& a, const float b        ) { return Vec2fa(a.x/b, a.y/b); }

132
  __forceinline Vec2fa operator /( const        float a, const Vec2fa& b ) { return Vec2fa(a/b.x, a/b.y); }

133


134
  __forceinline Vec2fa min( const Vec2fa& a, const Vec2fa& b ) {

135
    return Vec2fa(sycl::fmin(a.x,b.x), sycl::fmin(a.y,b.y));

136
  }

137
  __forceinline Vec2fa max( const Vec2fa& a, const Vec2fa& b ) {

138
    return Vec2fa(sycl::fmax(a.x,b.x), sycl::fmax(a.y,b.y));

139
  }

140


141
/*

142
#if defined(__SSE4_1__)

143
    __forceinline Vec2fa mini(const Vec2fa& a, const Vec2fa& b) {

144
      const vint4 ai = _mm_castps_si128(a);

145
      const vint4 bi = _mm_castps_si128(b);

146
      const vint4 ci = _mm_min_epi32(ai,bi);

147
      return _mm_castsi128_ps(ci);

148
    }

149
#endif

150


151
#if defined(__SSE4_1__)

152
    __forceinline Vec2fa maxi(const Vec2fa& a, const Vec2fa& b) {

153
      const vint4 ai = _mm_castps_si128(a);

154
      const vint4 bi = _mm_castps_si128(b);

155
      const vint4 ci = _mm_max_epi32(ai,bi);

156
      return _mm_castsi128_ps(ci);

157
    }

158
#endif

159


160
    __forceinline Vec2fa pow ( const Vec2fa& a, const float& b ) {

161
      return Vec2fa(powf(a.x,b),powf(a.y,b));

162
    }

163
*/

164
  

165
  ////////////////////////////////////////////////////////////////////////////////

166
  /// Ternary Operators

167
  ////////////////////////////////////////////////////////////////////////////////

168


169
  __forceinline Vec2fa madd  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return Vec2fa(madd(a.x,b.x,c.x), madd(a.y,b.y,c.y)); }

170
  __forceinline Vec2fa msub  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return Vec2fa(msub(a.x,b.x,c.x), msub(a.y,b.y,c.y)); }

171
  __forceinline Vec2fa nmadd ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return Vec2fa(nmadd(a.x,b.x,c.x), nmadd(a.y,b.y,c.y)); }

172
  __forceinline Vec2fa nmsub ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return Vec2fa(nmsub(a.x,b.x,c.x), nmsub(a.y,b.y,c.y)); }

173


174
  __forceinline Vec2fa madd  ( const float a, const Vec2fa& b, const Vec2fa& c) { return madd(Vec2fa(a),b,c); }

175
  __forceinline Vec2fa msub  ( const float a, const Vec2fa& b, const Vec2fa& c) { return msub(Vec2fa(a),b,c); }

176
  __forceinline Vec2fa nmadd ( const float a, const Vec2fa& b, const Vec2fa& c) { return nmadd(Vec2fa(a),b,c); }

177
  __forceinline Vec2fa nmsub ( const float a, const Vec2fa& b, const Vec2fa& c) { return nmsub(Vec2fa(a),b,c); }

178


179
  ////////////////////////////////////////////////////////////////////////////////

180
  /// Assignment Operators

181
  ////////////////////////////////////////////////////////////////////////////////

182


183
  __forceinline Vec2fa& operator +=( Vec2fa& a, const Vec2fa& b ) { return a = a + b; }

184
  __forceinline Vec2fa& operator -=( Vec2fa& a, const Vec2fa& b ) { return a = a - b; }

185
  __forceinline Vec2fa& operator *=( Vec2fa& a, const Vec2fa& b ) { return a = a * b; }

186
  __forceinline Vec2fa& operator *=( Vec2fa& a, const float   b ) { return a = a * b; }

187
  __forceinline Vec2fa& operator /=( Vec2fa& a, const Vec2fa& b ) { return a = a / b; }

188
  __forceinline Vec2fa& operator /=( Vec2fa& a, const float   b ) { return a = a / b; }

189


190
  ////////////////////////////////////////////////////////////////////////////////

191
  /// Reductions

192
  ////////////////////////////////////////////////////////////////////////////////

193


194
  __forceinline float reduce_add(const Vec2fa& v) { return v.x+v.y; }

195
  __forceinline float reduce_mul(const Vec2fa& v) { return v.x*v.y; }

196
  __forceinline float reduce_min(const Vec2fa& v) { return sycl::fmin(v.x,v.y); }

197
  __forceinline float reduce_max(const Vec2fa& v) { return sycl::fmax(v.x,v.y); }

198


199
  ////////////////////////////////////////////////////////////////////////////////

200
  /// Comparison Operators

201
  ////////////////////////////////////////////////////////////////////////////////

202


203
  __forceinline bool operator ==( const Vec2fa& a, const Vec2fa& b ) { return a.x == b.x && a.y == b.y; }

204
  __forceinline bool operator !=( const Vec2fa& a, const Vec2fa& b ) { return a.x != b.x || a.y != b.y; }

205


206
  ////////////////////////////////////////////////////////////////////////////////

207
  /// Euclidian Space Operators

208
  ////////////////////////////////////////////////////////////////////////////////

209


210
  __forceinline float dot ( const Vec2fa& a, const Vec2fa& b ) {

211
    return reduce_add(a*b);

212
  }

213


214
  __forceinline Vec2fa cross ( const Vec2fa& a ) {

215
    return Vec2fa(-a.y,a.x);

216
  }

217


218
  __forceinline float  sqr_length ( const Vec2fa& a )                { return dot(a,a); }

219
  __forceinline float  rcp_length ( const Vec2fa& a )                { return rsqrt(dot(a,a)); }

220
  __forceinline float  rcp_length2( const Vec2fa& a )                { return rcp(dot(a,a)); }

221
  __forceinline float  length   ( const Vec2fa& a )                  { return sqrt(dot(a,a)); }

222
  __forceinline Vec2fa normalize( const Vec2fa& a )                  { return a*rsqrt(dot(a,a)); }

223
  __forceinline float  distance ( const Vec2fa& a, const Vec2fa& b ) { return length(a-b); }

224


225
  ////////////////////////////////////////////////////////////////////////////////

226
  /// Select

227
  ////////////////////////////////////////////////////////////////////////////////

228


229
  __forceinline Vec2fa select( bool s, const Vec2fa& t, const Vec2fa& f ) {

230
    return Vec2fa(s ? t.x : f.x, s ? t.y : f.y);

231
  }

232


233
  __forceinline Vec2fa lerp(const Vec2fa& v0, const Vec2fa& v1, const float t) {

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

235
  }

236


237
  __forceinline int maxDim ( const Vec2fa& a )

238
  {

239
    const Vec2fa b = abs(a);

240
    if (b.x > b.y) return 0;

241
    else return 1;

242
  }

243


244
  ////////////////////////////////////////////////////////////////////////////////

245
  /// Rounding Functions

246
  ////////////////////////////////////////////////////////////////////////////////

247


248
  __forceinline Vec2fa trunc( const Vec2fa& a ) { return Vec2fa(sycl::trunc(a.x),sycl::trunc(a.y)); }

249
  __forceinline Vec2fa floor( const Vec2fa& a ) { return Vec2fa(sycl::floor(a.x),sycl::floor(a.y)); }

250
  __forceinline Vec2fa ceil ( const Vec2fa& a ) { return Vec2fa(sycl::ceil (a.x),sycl::ceil (a.y)); }

251


252
  ////////////////////////////////////////////////////////////////////////////////

253
  /// Output Operators

254
  ////////////////////////////////////////////////////////////////////////////////

255


256
  inline embree_ostream operator<<(embree_ostream cout, const Vec2fa& a) {

257
    return cout << "(" << a.x << ", " << a.y << ")";

258
  }

259


260
  /*template<>

261
  __forceinline vfloat_impl<4>::vfloat_impl(const Vec2fa& a)

262
  {

263
    v = 0;

264
    const unsigned int lid = get_sub_group_local_id();

265
    if (lid == 0) v = a.x;

266
    if (lid == 1) v = a.y;

267
  }*/

268


269
  typedef Vec2fa Vec2fa_t;

270
}

271


272