CoCalc -- vec3ia.h

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/common/math/vec3ia.h
⁹⁹¹² 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

9
#if defined(EMBREE_SYCL_SUPPORT) && defined(__SYCL_DEVICE_ONLY__)
10
#  include "vec3ia_sycl.h"
11
#else
12

13
#include "../simd/sse.h"
14

15
namespace embree
16
{
17
  ////////////////////////////////////////////////////////////////////////////////
18
  /// SSE Vec3ia Type
19
  ////////////////////////////////////////////////////////////////////////////////
20

21
  struct __aligned(16) Vec3ia
22
  {
23
    ALIGNED_STRUCT_(16);
24

25
    union {
26
      __m128i m128;
27
      struct { int x,y,z; };
28
    };
29

30
    typedef int Scalar;
31
    enum { N = 3 };
32

33
    ////////////////////////////////////////////////////////////////////////////////
34
    /// Constructors, Assignment & Cast Operators
35
    ////////////////////////////////////////////////////////////////////////////////
36

37
    __forceinline Vec3ia( ) {}
38
    __forceinline Vec3ia( const __m128i a ) : m128(a) {}
39
    __forceinline Vec3ia( const Vec3ia& other ) : m128(other.m128) {}
40
    __forceinline Vec3ia& operator =(const Vec3ia& other) { m128 = other.m128; return *this; }
41

42
    __forceinline explicit Vec3ia( const int a ) : m128(_mm_set1_epi32(a)) {}
43
    __forceinline          Vec3ia( const int x, const int y, const int z) : m128(_mm_set_epi32(z, z, y, x)) {}
44
    __forceinline explicit Vec3ia( const __m128 a ) : m128(_mm_cvtps_epi32(a)) {}
45

46
    __forceinline operator const __m128i&() const { return m128; }
47
    __forceinline operator       __m128i&()       { return m128; }
48

49
    ////////////////////////////////////////////////////////////////////////////////
50
    /// Constants
51
    ////////////////////////////////////////////////////////////////////////////////
52

53
    __forceinline Vec3ia( ZeroTy   ) : m128(_mm_setzero_si128()) {}
54
    __forceinline Vec3ia( OneTy    ) : m128(_mm_set1_epi32(1)) {}
55
    __forceinline Vec3ia( PosInfTy ) : m128(_mm_set1_epi32(pos_inf)) {}
56
    __forceinline Vec3ia( NegInfTy ) : m128(_mm_set1_epi32(neg_inf)) {}
57

58
    ////////////////////////////////////////////////////////////////////////////////
59
    /// Array Access
60
    ////////////////////////////////////////////////////////////////////////////////
61

62
    __forceinline const int& operator []( const size_t index ) const { assert(index < 3); return (&x)[index]; }
63
    __forceinline       int& operator []( const size_t index )       { assert(index < 3); return (&x)[index]; }
64
  };
65

66

67
  ////////////////////////////////////////////////////////////////////////////////
68
  /// Unary Operators
69
  ////////////////////////////////////////////////////////////////////////////////
70

71
  __forceinline Vec3ia operator +( const Vec3ia& a ) { return a; }
72
  __forceinline Vec3ia operator -( const Vec3ia& a ) { return _mm_sub_epi32(_mm_setzero_si128(), a.m128); }
73
#if (defined(__aarch64__))
74
  __forceinline Vec3ia abs       ( const Vec3ia& a ) { return vabsq_s32(a.m128); }
75
#elif defined(__SSSE3__)
76
  __forceinline Vec3ia abs       ( const Vec3ia& a ) { return _mm_abs_epi32(a.m128); }
77
#endif
78

79
  ////////////////////////////////////////////////////////////////////////////////
80
  /// Binary Operators
81
  ////////////////////////////////////////////////////////////////////////////////
82

83
  __forceinline Vec3ia operator +( const Vec3ia& a, const Vec3ia& b ) { return _mm_add_epi32(a.m128, b.m128); }
84
  __forceinline Vec3ia operator +( const Vec3ia& a, const int     b ) { return a+Vec3ia(b); }
85
  __forceinline Vec3ia operator +( const int     a, const Vec3ia& b ) { return Vec3ia(a)+b; }
86

87
  __forceinline Vec3ia operator -( const Vec3ia& a, const Vec3ia& b ) { return _mm_sub_epi32(a.m128, b.m128); }
88
  __forceinline Vec3ia operator -( const Vec3ia& a, const int     b ) { return a-Vec3ia(b); }
89
  __forceinline Vec3ia operator -( const int     a, const Vec3ia& b ) { return Vec3ia(a)-b; }
90

91
#if defined(__aarch64__) || defined(__SSE4_1__)
92
  __forceinline Vec3ia operator *( const Vec3ia& a, const Vec3ia& b ) { return _mm_mullo_epi32(a.m128, b.m128); }
93
  __forceinline Vec3ia operator *( const Vec3ia& a, const int     b ) { return a * Vec3ia(b); }
94
  __forceinline Vec3ia operator *( const int     a, const Vec3ia& b ) { return Vec3ia(a) * b; }
95
#endif
96

97
  __forceinline Vec3ia operator &( const Vec3ia& a, const Vec3ia& b ) { return _mm_and_si128(a.m128, b.m128); }
98
  __forceinline Vec3ia operator &( const Vec3ia& a, const int     b ) { return a & Vec3ia(b); }
99
  __forceinline Vec3ia operator &( const int     a, const Vec3ia& b ) { return Vec3ia(a) & b; }
100

101
  __forceinline Vec3ia operator |( const Vec3ia& a, const Vec3ia& b ) { return _mm_or_si128(a.m128, b.m128); }
102
  __forceinline Vec3ia operator |( const Vec3ia& a, const int     b ) { return a | Vec3ia(b); }
103
  __forceinline Vec3ia operator |( const int     a, const Vec3ia& b ) { return Vec3ia(a) | b; }
104

105
  __forceinline Vec3ia operator ^( const Vec3ia& a, const Vec3ia& b ) { return _mm_xor_si128(a.m128, b.m128); }
106
  __forceinline Vec3ia operator ^( const Vec3ia& a, const int     b ) { return a ^ Vec3ia(b); }
107
  __forceinline Vec3ia operator ^( const int     a, const Vec3ia& b ) { return Vec3ia(a) ^ b; }
108

109
  __forceinline Vec3ia operator <<( const Vec3ia& a, const int n ) { return _mm_slli_epi32(a.m128, n); }
110
  __forceinline Vec3ia operator >>( const Vec3ia& a, const int n ) { return _mm_srai_epi32(a.m128, n); }
111

112
  __forceinline Vec3ia sll ( const Vec3ia& a, const int b ) { return _mm_slli_epi32(a.m128, b); }
113
  __forceinline Vec3ia sra ( const Vec3ia& a, const int b ) { return _mm_srai_epi32(a.m128, b); }
114
  __forceinline Vec3ia srl ( const Vec3ia& a, const int b ) { return _mm_srli_epi32(a.m128, b); }
115

116
  ////////////////////////////////////////////////////////////////////////////////
117
  /// Assignment Operators
118
  ////////////////////////////////////////////////////////////////////////////////
119

120
  __forceinline Vec3ia& operator +=( Vec3ia& a, const Vec3ia& b ) { return a = a + b; }
121
  __forceinline Vec3ia& operator +=( Vec3ia& a, const int&   b ) { return a = a + b; }
122
  
123
  __forceinline Vec3ia& operator -=( Vec3ia& a, const Vec3ia& b ) { return a = a - b; }
124
  __forceinline Vec3ia& operator -=( Vec3ia& a, const int&   b ) { return a = a - b; }
125
  
126
#if defined(__aarch64__) || defined(__SSE4_1__)
127
  __forceinline Vec3ia& operator *=( Vec3ia& a, const Vec3ia& b ) { return a = a * b; }
128
  __forceinline Vec3ia& operator *=( Vec3ia& a, const int&    b ) { return a = a * b; }
129
#endif
130
  
131
  __forceinline Vec3ia& operator &=( Vec3ia& a, const Vec3ia& b ) { return a = a & b; }
132
  __forceinline Vec3ia& operator &=( Vec3ia& a, const int&    b ) { return a = a & b; }
133
  
134
  __forceinline Vec3ia& operator |=( Vec3ia& a, const Vec3ia& b ) { return a = a | b; }
135
  __forceinline Vec3ia& operator |=( Vec3ia& a, const int&    b ) { return a = a | b; }
136
  
137
#if !defined(__ARM_NEON)
138
  __forceinline Vec3ia& operator <<=( Vec3ia& a, const int& b ) { return a = a << b; }
139
  __forceinline Vec3ia& operator >>=( Vec3ia& a, const int& b ) { return a = a >> b; }
140
#endif
141

142
  ////////////////////////////////////////////////////////////////////////////////
143
  /// Select
144
  ////////////////////////////////////////////////////////////////////////////////
145

146
  __forceinline Vec3ia select( const Vec3ba& m, const Vec3ia& t, const Vec3ia& f ) {
147
#if defined(__aarch64__) || defined(__SSE4_1__)
148
    return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(f), _mm_castsi128_ps(t), m));
149
#else
150
    return _mm_or_si128(_mm_and_si128(_mm_castps_si128(m), t), _mm_andnot_si128(_mm_castps_si128(m), f)); 
151
#endif
152
  }
153

154
  ////////////////////////////////////////////////////////////////////////////////
155
  /// Reductions
156
  ////////////////////////////////////////////////////////////////////////////////
157
#if defined(__aarch64__)
158
  __forceinline int reduce_add(const Vec3ia& v) { return vaddvq_s32(select(Vec3ba(1,1,1),v,Vec3ia(0))); }
159
  __forceinline int reduce_mul(const Vec3ia& v) { return v.x*v.y*v.z; }
160
  __forceinline int reduce_min(const Vec3ia& v) { return vminvq_s32(select(Vec3ba(1,1,1),v,Vec3ia(0x7FFFFFFF))); }
161
  __forceinline int reduce_max(const Vec3ia& v) { return vmaxvq_s32(select(Vec3ba(1,1,1),v,Vec3ia(0x80000000))); }
162
#else
163
  __forceinline int reduce_add(const Vec3ia& v) { return v.x+v.y+v.z; }
164
  __forceinline int reduce_mul(const Vec3ia& v) { return v.x*v.y*v.z; }
165
  __forceinline int reduce_min(const Vec3ia& v) { return min(v.x,v.y,v.z); }
166
  __forceinline int reduce_max(const Vec3ia& v) { return max(v.x,v.y,v.z); }
167
#endif
168
  
169
  ////////////////////////////////////////////////////////////////////////////////
170
  /// Comparison Operators
171
  ////////////////////////////////////////////////////////////////////////////////
172

173
  __forceinline bool operator ==( const Vec3ia& a, const Vec3ia& b ) { return (_mm_movemask_ps(_mm_castsi128_ps(_mm_cmpeq_epi32(a.m128, b.m128))) & 7) == 7; }
174
  __forceinline bool operator !=( const Vec3ia& a, const Vec3ia& b ) { return (_mm_movemask_ps(_mm_castsi128_ps(_mm_cmpeq_epi32(a.m128, b.m128))) & 7) != 7; }
175
  __forceinline bool operator < ( const Vec3ia& a, const Vec3ia& b ) {
176
    if (a.x != b.x) return a.x < b.x;
177
    if (a.y != b.y) return a.y < b.y;
178
    if (a.z != b.z) return a.z < b.z;
179
    return false;
180
  }
181

182
  __forceinline Vec3ba eq_mask( const Vec3ia& a, const Vec3ia& b ) { return _mm_castsi128_ps(_mm_cmpeq_epi32 (a.m128, b.m128)); }
183
  __forceinline Vec3ba lt_mask( const Vec3ia& a, const Vec3ia& b ) { return _mm_castsi128_ps(_mm_cmplt_epi32 (a.m128, b.m128)); }
184
  __forceinline Vec3ba gt_mask( const Vec3ia& a, const Vec3ia& b ) { return _mm_castsi128_ps(_mm_cmpgt_epi32 (a.m128, b.m128)); }
185

186
#if defined(__aarch64__) || defined(__SSE4_1__)
187
  __forceinline Vec3ia min( const Vec3ia& a, const Vec3ia& b ) { return _mm_min_epi32(a.m128,b.m128); }
188
  __forceinline Vec3ia max( const Vec3ia& a, const Vec3ia& b ) { return _mm_max_epi32(a.m128,b.m128); }
189
#else
190
  __forceinline Vec3ia min( const Vec3ia& a, const Vec3ia& b ) { return select(lt_mask(a,b),a,b); }
191
  __forceinline Vec3ia max( const Vec3ia& a, const Vec3ia& b ) { return select(gt_mask(a,b),a,b); }
192
#endif
193

194
  ////////////////////////////////////////////////////////////////////////////////
195
  /// Output Operators
196
  ////////////////////////////////////////////////////////////////////////////////
197

198
  __forceinline embree_ostream operator<<(embree_ostream cout, const Vec3ia& a) {
199
    return cout << "(" << a.x << ", " << a.y << ", " << a.z << ")";
200
  }
201
}
202

203
#endif
204

205
Product

Resources

Company
