Removed accessors in vector classes again, cast operators are now all explicit except for one to avoid ambiguities.

Author: stefanatwork

common/math/linearspace3.h

@@ -96,7 +96,7 @@ namespace embree
   /*! compute transposed matrix */
   template<> __forceinline const LinearSpace3<Vec3fa> LinearSpace3<Vec3fa>::transposed() const { 
     vfloat4 rx,ry,rz; transpose((vfloat4&)vx,(vfloat4&)vy,(vfloat4&)vz,vfloat4(zero),rx,ry,rz);
-    return LinearSpace3<Vec3fa>(Vec3fa(rx.m128()),Vec3fa(ry.m128()),Vec3fa(rz.m128())); 
+    return LinearSpace3<Vec3fa>(Vec3fa(rx),Vec3fa(ry),Vec3fa(rz)); 
   }
 #endif
 

common/math/vec2fa.h

@@ -25,7 +25,7 @@ namespace embree
     typedef float Scalar;
     enum { N = 2 };
     union {
-      __m128 v;
+      __m128 m128;
       struct { float x,y,az,aw; };
     };
 
@@ -34,25 +34,23 @@ namespace embree
     ////////////////////////////////////////////////////////////////////////////////
 
     __forceinline Vec2fa( ) {}
-    __forceinline Vec2fa( const __m128 a ) : v(a) {}
+    __forceinline Vec2fa( const __m128 a ) : m128(a) {}
 
     __forceinline Vec2fa            ( const Vec2<float>& other  ) { x = other.x; y = other.y; }
     __forceinline Vec2fa& operator =( const Vec2<float>& other ) { x = other.x; y = other.y; return *this; }
 
-    __forceinline Vec2fa            ( const Vec2fa& other ) { v = other.v; }
-    __forceinline Vec2fa& operator =( const Vec2fa& other ) { v = other.v; return *this; }
+    __forceinline Vec2fa            ( const Vec2fa& other ) { m128 = other.m128; }
+    __forceinline Vec2fa& operator =( const Vec2fa& other ) { m128 = other.m128; return *this; }
 
-    __forceinline explicit Vec2fa( const float a ) : v(_mm_set1_ps(a)) {}
-    __forceinline          Vec2fa( const float x, const float y) : v(_mm_set_ps(y, y, y, x)) {}
+    __forceinline explicit Vec2fa( const float a ) : m128(_mm_set1_ps(a)) {}
+    __forceinline          Vec2fa( const float x, const float y) : m128(_mm_set_ps(y, y, y, x)) {}
 
 #if !defined(_M_ARM64) || defined(__clang__)
-    __forceinline explicit Vec2fa( const __m128i a ) : v(_mm_cvtepi32_ps(a)) {}
+    __forceinline explicit Vec2fa( const __m128i a ) : m128(_mm_cvtepi32_ps(a)) {}
 #endif
 
-    __forceinline const __m128& m128() const { return v; }
-    __forceinline __m128& m128()       { return v; }
-
-    __forceinline operator vfloat4() const { return vfloat4(m128()); }
+    __forceinline operator const __m128&() const { return m128; }
+    __forceinline operator       __m128&()       { return m128; }
 
     ////////////////////////////////////////////////////////////////////////////////
     /// Loads and Stores
@@ -67,17 +65,17 @@ namespace embree
     }
 
     static __forceinline void storeu ( void* ptr, const Vec2fa& v ) {
-      _mm_storeu_ps((float*)ptr,v.m128());
+      _mm_storeu_ps((float*)ptr,v);
     }
 
     ////////////////////////////////////////////////////////////////////////////////
     /// Constants
     ////////////////////////////////////////////////////////////////////////////////
 
-    __forceinline Vec2fa( ZeroTy   ) : v(_mm_setzero_ps()) {}
-    __forceinline Vec2fa( OneTy    ) : v(_mm_set1_ps(1.0f)) {}
-    __forceinline Vec2fa( PosInfTy ) : v(_mm_set1_ps(pos_inf)) {}
-    __forceinline Vec2fa( NegInfTy ) : v(_mm_set1_ps(neg_inf)) {}
+    __forceinline Vec2fa( ZeroTy   ) : m128(_mm_setzero_ps()) {}
+    __forceinline Vec2fa( OneTy    ) : m128(_mm_set1_ps(1.0f)) {}
+    __forceinline Vec2fa( PosInfTy ) : m128(_mm_set1_ps(pos_inf)) {}
+    __forceinline Vec2fa( NegInfTy ) : m128(_mm_set1_ps(neg_inf)) {}
 
     ////////////////////////////////////////////////////////////////////////////////
     /// Array Access
@@ -94,66 +92,66 @@ namespace embree
   __forceinline Vec2fa operator +( const Vec2fa& a ) { return a; }
   __forceinline Vec2fa operator -( const Vec2fa& a ) {
     const __m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x80000000));
-    return _mm_xor_ps(a.v, mask);
+    return _mm_xor_ps(a.m128, mask);
   }
   __forceinline Vec2fa abs  ( const Vec2fa& a ) {
     const __m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff));
-    return _mm_and_ps(a.v, mask);
+    return _mm_and_ps(a.m128, mask);
   }
   __forceinline Vec2fa sign ( const Vec2fa& a ) {
-    return blendv_ps(Vec2fa(one).m128(), (-Vec2fa(one)).m128(), _mm_cmplt_ps (a.m128(),Vec2fa(zero).m128()));
+    return blendv_ps(Vec2fa(one), -Vec2fa(one), _mm_cmplt_ps (a,Vec2fa(zero)));
   }
 
   __forceinline Vec2fa rcp  ( const Vec2fa& a )
   {
 #if defined(__aarch64__) || defined(_M_ARM64)
-        __m128 reciprocal = _mm_rcp_ps(a.v);
-        reciprocal = vmulq_f32(vrecpsq_f32(a.v, reciprocal), reciprocal);
-        reciprocal = vmulq_f32(vrecpsq_f32(a.v, reciprocal), reciprocal);
+        __m128 reciprocal = _mm_rcp_ps(a.m128);
+        reciprocal = vmulq_f32(vrecpsq_f32(a.m128, reciprocal), reciprocal);
+        reciprocal = vmulq_f32(vrecpsq_f32(a.m128, reciprocal), reciprocal);
         return (const Vec2fa)reciprocal;
 #else
 #if defined(__AVX512VL__)
-    const Vec2fa r = _mm_rcp14_ps(a.v);
+    const Vec2fa r = _mm_rcp14_ps(a.m128);
 #else
-    const Vec2fa r = _mm_rcp_ps(a.v);
+    const Vec2fa r = _mm_rcp_ps(a.m128);
 #endif
 
 #if defined(__AVX2__)
-    const Vec2fa h_n = _mm_fnmadd_ps(a.m128(), r.m128(), vfloat4(1.0).m128());  // First, compute 1 - a * r (which will be very close to 0)
-    const Vec2fa res = _mm_fmadd_ps(r.m128(), h_n.m128(), r.m128());            // Then compute r + r * h_n
+    const Vec2fa h_n = _mm_fnmadd_ps(a, r, vfloat4(1.0));  // First, compute 1 - a * r (which will be very close to 0)
+    const Vec2fa res = _mm_fmadd_ps(r, h_n, r);            // Then compute r + r * h_n
 #else
-    const Vec2fa h_n = _mm_sub_ps(vfloat4(1.0f).m128(), _mm_mul_ps(a.m128(), r.m128()));  // First, compute 1 - a * r (which will be very close to 0)
-    const Vec2fa res = _mm_add_ps(r.m128(),_mm_mul_ps(r.m128(), h_n.m128()));             // Then compute r + r * h_n  
+    const Vec2fa h_n = _mm_sub_ps(vfloat4(1.0f), _mm_mul_ps(a, r));  // First, compute 1 - a * r (which will be very close to 0)
+    const Vec2fa res = _mm_add_ps(r,_mm_mul_ps(r, h_n));             // Then compute r + r * h_n  
 #endif
 
     return res;
 #endif  //defined(__aarch64__) || defined(_M_ARM64)
   }
 
-  __forceinline Vec2fa sqrt ( const Vec2fa& a ) { return _mm_sqrt_ps(a.v); }
-  __forceinline Vec2fa sqr  ( const Vec2fa& a ) { return _mm_mul_ps(a.m128(),a.m128()); }
+  __forceinline Vec2fa sqrt ( const Vec2fa& a ) { return _mm_sqrt_ps(a.m128); }
+  __forceinline Vec2fa sqr  ( const Vec2fa& a ) { return _mm_mul_ps(a,a); }
 
   __forceinline Vec2fa rsqrt( const Vec2fa& a )
   {
 #if defined(__aarch64__) || defined(_M_ARM64)
-        __m128 r = _mm_rsqrt_ps(a.v);
-        r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a.v, r), r));
-        r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a.v, r), r));
+        __m128 r = _mm_rsqrt_ps(a.m128);
+        r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a.m128, r), r));
+        r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a.m128, r), r));
         return r;
 #else
 
 #if defined(__AVX512VL__)
-    __m128 r = _mm_rsqrt14_ps(a.v);
+    __m128 r = _mm_rsqrt14_ps(a.m128);
 #else
-    __m128 r = _mm_rsqrt_ps(a.v);
+    __m128 r = _mm_rsqrt_ps(a.m128);
 #endif
-    return _mm_add_ps(_mm_mul_ps(_mm_set1_ps(1.5f),r), _mm_mul_ps(_mm_mul_ps(_mm_mul_ps(a.m128(), _mm_set1_ps(-0.5f)), r), _mm_mul_ps(r, r)));
+    return _mm_add_ps(_mm_mul_ps(_mm_set1_ps(1.5f),r), _mm_mul_ps(_mm_mul_ps(_mm_mul_ps(a, _mm_set1_ps(-0.5f)), r), _mm_mul_ps(r, r)));
 
 #endif
   }
 
   __forceinline Vec2fa zero_fix(const Vec2fa& a) {
-    return blendv_ps(a.m128(), _mm_set1_ps(min_rcp_input), _mm_cmplt_ps (abs(a).v, _mm_set1_ps(min_rcp_input)));
+    return blendv_ps(a, _mm_set1_ps(min_rcp_input), _mm_cmplt_ps (abs(a).m128, _mm_set1_ps(min_rcp_input)));
   }
   __forceinline Vec2fa rcp_safe(const Vec2fa& a) {
     return rcp(zero_fix(a));
@@ -170,33 +168,33 @@ namespace embree
   /// Binary Operators
   ////////////////////////////////////////////////////////////////////////////////
 
-  __forceinline Vec2fa operator +( const Vec2fa& a, const Vec2fa& b ) { return _mm_add_ps(a.v, b.v); }
-  __forceinline Vec2fa operator -( const Vec2fa& a, const Vec2fa& b ) { return _mm_sub_ps(a.v, b.v); }
-  __forceinline Vec2fa operator *( const Vec2fa& a, const Vec2fa& b ) { return _mm_mul_ps(a.v, b.v); }
+  __forceinline Vec2fa operator +( const Vec2fa& a, const Vec2fa& b ) { return _mm_add_ps(a.m128, b.m128); }
+  __forceinline Vec2fa operator -( const Vec2fa& a, const Vec2fa& b ) { return _mm_sub_ps(a.m128, b.m128); }
+  __forceinline Vec2fa operator *( const Vec2fa& a, const Vec2fa& b ) { return _mm_mul_ps(a.m128, b.m128); }
   __forceinline Vec2fa operator *( const Vec2fa& a, const float b ) { return a * Vec2fa(b); }
   __forceinline Vec2fa operator *( const float a, const Vec2fa& b ) { return Vec2fa(a) * b; }
-  __forceinline Vec2fa operator /( const Vec2fa& a, const Vec2fa& b ) { return _mm_div_ps(a.v,b.v); }
-  __forceinline Vec2fa operator /( const Vec2fa& a, const float b        ) { return _mm_div_ps(a.v,_mm_set1_ps(b)); }
-  __forceinline Vec2fa operator /( const        float a, const Vec2fa& b ) { return _mm_div_ps(_mm_set1_ps(a),b.v); }
+  __forceinline Vec2fa operator /( const Vec2fa& a, const Vec2fa& b ) { return _mm_div_ps(a.m128,b.m128); }
+  __forceinline Vec2fa operator /( const Vec2fa& a, const float b        ) { return _mm_div_ps(a.m128,_mm_set1_ps(b)); }
+  __forceinline Vec2fa operator /( const        float a, const Vec2fa& b ) { return _mm_div_ps(_mm_set1_ps(a),b.m128); }
 
-  __forceinline Vec2fa min( const Vec2fa& a, const Vec2fa& b ) { return _mm_min_ps(a.v,b.v); }
-  __forceinline Vec2fa max( const Vec2fa& a, const Vec2fa& b ) { return _mm_max_ps(a.v,b.v); }
+  __forceinline Vec2fa min( const Vec2fa& a, const Vec2fa& b ) { return _mm_min_ps(a.m128,b.m128); }
+  __forceinline Vec2fa max( const Vec2fa& a, const Vec2fa& b ) { return _mm_max_ps(a.m128,b.m128); }
 
 #if defined(__aarch64__) || defined(_M_ARM64) || defined(__SSE4_1__)
     __forceinline Vec2fa mini(const Vec2fa& a, const Vec2fa& b) {
-      const vint4 ai = _mm_castps_si128(a.m128());
-      const vint4 bi = _mm_castps_si128(b.m128());
-      const vint4 ci = _mm_min_epi32(ai.m128i(),bi.m128i());
-      return _mm_castsi128_ps(ci.m128i());
+      const vint4 ai = _mm_castps_si128(a);
+      const vint4 bi = _mm_castps_si128(b);
+      const vint4 ci = _mm_min_epi32(ai,bi);
+      return _mm_castsi128_ps(ci);
     }
 #endif
 
 #if defined(__aarch64__) || defined(_M_ARM64) || defined(__SSE4_1__)
     __forceinline Vec2fa maxi(const Vec2fa& a, const Vec2fa& b) {
-      const vint4 ai = _mm_castps_si128(a.m128());
-      const vint4 bi = _mm_castps_si128(b.m128());
-      const vint4 ci = _mm_max_epi32(ai.m128i(),bi.m128i());
-      return _mm_castsi128_ps(ci.m128i());
+      const vint4 ai = _mm_castps_si128(a);
+      const vint4 bi = _mm_castps_si128(b);
+      const vint4 ci = _mm_max_epi32(ai,bi);
+      return _mm_castsi128_ps(ci);
     }
 #endif
 
@@ -209,10 +207,10 @@ namespace embree
   ////////////////////////////////////////////////////////////////////////////////
 
 #if defined(__AVX2__)
-  __forceinline Vec2fa madd  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fmadd_ps(a.m128(),b.m128(),c.m128()); }
-  __forceinline Vec2fa msub  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fmsub_ps(a.m128(),b.m128(),c.m128()); }
-  __forceinline Vec2fa nmadd ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fnmadd_ps(a.m128(),b.m128(),c.m128()); }
-  __forceinline Vec2fa nmsub ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fnmsub_ps(a.m128(),b.m128(),c.m128()); }
+  __forceinline Vec2fa madd  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fmadd_ps(a,b,c); }
+  __forceinline Vec2fa msub  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fmsub_ps(a,b,c); }
+  __forceinline Vec2fa nmadd ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fnmadd_ps(a,b,c); }
+  __forceinline Vec2fa nmsub ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return _mm_fnmsub_ps(a,b,c); }
 #else
   __forceinline Vec2fa madd  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return a*b+c; }
   __forceinline Vec2fa msub  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { return a*b-c; }
@@ -249,16 +247,16 @@ namespace embree
   /// Comparison Operators
   ////////////////////////////////////////////////////////////////////////////////
 
-  __forceinline bool operator ==( const Vec2fa& a, const Vec2fa& b ) { return (_mm_movemask_ps(_mm_cmpeq_ps (a.v, b.v)) & 3) == 3; }
-  __forceinline bool operator !=( const Vec2fa& a, const Vec2fa& b ) { return (_mm_movemask_ps(_mm_cmpneq_ps(a.v, b.v)) & 3) != 0; }
+  __forceinline bool operator ==( const Vec2fa& a, const Vec2fa& b ) { return (_mm_movemask_ps(_mm_cmpeq_ps (a.m128, b.m128)) & 3) == 3; }
+  __forceinline bool operator !=( const Vec2fa& a, const Vec2fa& b ) { return (_mm_movemask_ps(_mm_cmpneq_ps(a.m128, b.m128)) & 3) != 0; }
 
   ////////////////////////////////////////////////////////////////////////////////
   /// Euclidean Space Operators
   ////////////////////////////////////////////////////////////////////////////////
 
 #if defined(__SSE4_1__)
   __forceinline float dot ( const Vec2fa& a, const Vec2fa& b ) {
-    return _mm_cvtss_f32(_mm_dp_ps(a.m128(),b.m128(),0x3F));
+    return _mm_cvtss_f32(_mm_dp_ps(a,b,0x3F));
   }
 #else
   __forceinline float dot ( const Vec2fa& a, const Vec2fa& b ) {
@@ -283,7 +281,7 @@ namespace embree
 
   __forceinline Vec2fa select( bool s, const Vec2fa& t, const Vec2fa& f ) {
     __m128 mask = s ? _mm_castsi128_ps(_mm_cmpeq_epi32(_mm_setzero_si128(), _mm_setzero_si128())) : _mm_setzero_ps();
-    return blendv_ps(f.m128(), t.m128(), mask);
+    return blendv_ps(f, t, mask);
   }
 
   __forceinline Vec2fa lerp(const Vec2fa& v0, const Vec2fa& v1, const float t) {
@@ -303,12 +301,12 @@ namespace embree
 
 #if defined(__aarch64__) || defined(_M_ARM64)
   //__forceinline Vec2fa trunc(const Vec2fa& a) { return vrndq_f32(a); }
-  __forceinline Vec2fa floor(const Vec2fa& a) { return vrndmq_f32(a.v); }
-  __forceinline Vec2fa ceil (const Vec2fa& a) { return vrndpq_f32(a.v); }
+  __forceinline Vec2fa floor(const Vec2fa& a) { return vrndmq_f32(a); }
+  __forceinline Vec2fa ceil (const Vec2fa& a) { return vrndpq_f32(a); }
 #elif defined (__SSE4_1__)
   //__forceinline Vec2fa trunc( const Vec2fa& a ) { return _mm_round_ps(a, _MM_FROUND_TO_NEAREST_INT); }
-  __forceinline Vec2fa floor( const Vec2fa& a ) { return _mm_round_ps(a.m128(), _MM_FROUND_TO_NEG_INF    ); }
-  __forceinline Vec2fa ceil ( const Vec2fa& a ) { return _mm_round_ps(a.m128(), _MM_FROUND_TO_POS_INF    ); }
+  __forceinline Vec2fa floor( const Vec2fa& a ) { return _mm_round_ps(a, _MM_FROUND_TO_NEG_INF    ); }
+  __forceinline Vec2fa ceil ( const Vec2fa& a ) { return _mm_round_ps(a, _MM_FROUND_TO_POS_INF    ); }
 #else
   //__forceinline Vec2fa trunc( const Vec2fa& a ) { return Vec2fa(truncf(a.x),truncf(a.y),truncf(a.z)); }
   __forceinline Vec2fa floor( const Vec2fa& a ) { return Vec2fa(floorf(a.x),floorf(a.y)); }

common/math/vec3.h

@@ -295,7 +295,7 @@ namespace embree
 #elif defined(__SSE__) || defined(__ARM_NEON) || defined(_M_ARM64)
   template<>
   __forceinline Vec3<vfloat4>::Vec3(const Vec3fa& a) {
-    const vfloat4 v = vfloat4(a.v); x = shuffle<0,0,0,0>(v); y = shuffle<1,1,1,1>(v); z = shuffle<2,2,2,2>(v);
+    const vfloat4 v = vfloat4(a.m128); x = shuffle<0,0,0,0>(v); y = shuffle<1,1,1,1>(v); z = shuffle<2,2,2,2>(v);
   }
 #endif