vboolf4_sse2.h | Explore in Territory

// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0

#pragma once

#define vboolf …
#define vboold …
#define vint …
#define vuint …
#define vllong …
#define vfloat …
#define vdouble …

namespace embree
{
  /* 4-wide SSE bool type */
  template<>
  struct vboolf<4>
  { … };

  ////////////////////////////////////////////////////////////////////////////////
  /// Unary Operators
  ////////////////////////////////////////////////////////////////////////////////
  
  __forceinline vboolf4 operator !(const vboolf4& a) { … }
  
  ////////////////////////////////////////////////////////////////////////////////
  /// Binary Operators
  ////////////////////////////////////////////////////////////////////////////////
  
  __forceinline vboolf4 operator &(const vboolf4& a, const vboolf4& b) { … }
  __forceinline vboolf4 operator |(const vboolf4& a, const vboolf4& b) { … }
  __forceinline vboolf4 operator ^(const vboolf4& a, const vboolf4& b) { … }

  __forceinline vboolf4 andn(const vboolf4& a, const vboolf4& b) { … }
  
  ////////////////////////////////////////////////////////////////////////////////
  /// Assignment Operators
  ////////////////////////////////////////////////////////////////////////////////
  
  __forceinline vboolf4& operator &=(vboolf4& a, const vboolf4& b) { … }
  __forceinline vboolf4& operator |=(vboolf4& a, const vboolf4& b) { … }
  __forceinline vboolf4& operator ^=(vboolf4& a, const vboolf4& b) { … }
  
  ////////////////////////////////////////////////////////////////////////////////
  /// Comparison Operators + Select
  ////////////////////////////////////////////////////////////////////////////////
  
  __forceinline vboolf4 operator !=(const vboolf4& a, const vboolf4& b) { … }
  __forceinline vboolf4 operator ==(const vboolf4& a, const vboolf4& b) { … }
  
  __forceinline vboolf4 select(const vboolf4& m, const vboolf4& t, const vboolf4& f) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Movement/Shifting/Shuffling Functions
  ////////////////////////////////////////////////////////////////////////////////
  
  __forceinline vboolf4 unpacklo(const vboolf4& a, const vboolf4& b) { … }
  __forceinline vboolf4 unpackhi(const vboolf4& a, const vboolf4& b) { … }

#if defined(__aarch64__)
  template<int i0, int i1, int i2, int i3>
  __forceinline vboolf4 shuffle(const vboolf4& v) {
    return vreinterpretq_f32_u8(vqtbl1q_u8( vreinterpretq_u8_s32((int32x4_t)v.v), _MN_SHUFFLE(i0, i1, i2, i3)));
  }

  template<int i0, int i1, int i2, int i3>
  __forceinline vboolf4 shuffle(const vboolf4& a, const vboolf4& b) {
    return vreinterpretq_f32_u8(vqtbl2q_u8( (uint8x16x2_t){(uint8x16_t)a.v, (uint8x16_t)b.v}, _MF_SHUFFLE(i0, i1, i2, i3)));
  }
#else
  template<int i0, int i1, int i2, int i3>
  __forceinline vboolf4 shuffle(const vboolf4& v) { … }

  template<int i0, int i1, int i2, int i3>
  __forceinline vboolf4 shuffle(const vboolf4& a, const vboolf4& b) { … }
#endif

  template<int i0>
  __forceinline vboolf4 shuffle(const vboolf4& v) { … }

#if defined(__SSE3__)
  template<> __forceinline vboolf4 shuffle<0, 0, 2, 2>(const vboolf4& v) { return _mm_moveldup_ps(v); }
  template<> __forceinline vboolf4 shuffle<1, 1, 3, 3>(const vboolf4& v) { return _mm_movehdup_ps(v); }
  template<> __forceinline vboolf4 shuffle<0, 1, 0, 1>(const vboolf4& v) { return _mm_castpd_ps(_mm_movedup_pd(v)); }
#endif

#if defined(__SSE4_1__) && !defined(__aarch64__)
  template<int dst, int src, int clr> __forceinline vboolf4 insert(const vboolf4& a, const vboolf4& b) { return _mm_insert_ps(a, b, (dst << 4) | (src << 6) | clr); }
  template<int dst, int src> __forceinline vboolf4 insert(const vboolf4& a, const vboolf4& b) { return insert<dst, src, 0>(a, b); }
  template<int dst> __forceinline vboolf4 insert(const vboolf4& a, const bool b) { return insert<dst, 0>(a, vboolf4(b)); }
#endif
  
  ////////////////////////////////////////////////////////////////////////////////
  /// Reduction Operations
  ////////////////////////////////////////////////////////////////////////////////
    
  __forceinline bool reduce_and(const vboolf4& a) { … }
  __forceinline bool reduce_or (const vboolf4& a) { … }

  __forceinline bool all (const vboolf4& b) { … }
  __forceinline bool any (const vboolf4& b) { … }
  __forceinline bool none(const vboolf4& b) { … }

  __forceinline bool all (const vboolf4& valid, const vboolf4& b) { … }
  __forceinline bool any (const vboolf4& valid, const vboolf4& b) { … }
  __forceinline bool none(const vboolf4& valid, const vboolf4& b) { … }
  
  __forceinline size_t movemask(const vboolf4& a) { … }
#if defined(__aarch64__)
  __forceinline size_t popcnt(const vboolf4& a) { return vaddvq_s32(vandq_u32(vreinterpretq_u32_f32(a.v),_mm_set1_epi32(1))); }
#elif defined(__SSE4_2__)
  __forceinline size_t popcnt(const vboolf4& a) { return popcnt((size_t)_mm_movemask_ps(a)); }
#else
  __forceinline size_t popcnt(const vboolf4& a) { … }
#endif

  ////////////////////////////////////////////////////////////////////////////////
  /// Get/Set Functions
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline bool get(const vboolf4& a, size_t index) { … }
  __forceinline void set(vboolf4& a, size_t index)       { … }
  __forceinline void clear(vboolf4& a, size_t index)     { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Output Operators
  ////////////////////////////////////////////////////////////////////////////////
  
  __forceinline embree_ostream operator <<(embree_ostream cout, const vboolf4& a) { … }
}

#undef vboolf
#undef vboold
#undef vint
#undef vuint
#undef vllong
#undef vfloat
#undef vdouble
godot/thirdparty/embree/common/simd/vboolf4_sse2.h
