vec3fa.h | Explore in Territory

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

#pragma once

#include "../sys/alloc.h"
#include "emath.h"

#if defined(EMBREE_SYCL_SUPPORT) && defined(__SYCL_DEVICE_ONLY__)
#  include "vec3fa_sycl.h"
#else

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

namespace embree
{
  ////////////////////////////////////////////////////////////////////////////////
  /// SSE Vec3fa Type
  ////////////////////////////////////////////////////////////////////////////////

  struct __aligned(16) Vec3fa
  { … };

  ////////////////////////////////////////////////////////////////////////////////
  /// Unary Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fa operator +( const Vec3fa& a ) { … }
  __forceinline Vec3fa operator -( const Vec3fa& a ) { … }
  __forceinline Vec3fa abs  ( const Vec3fa& a ) { … }
  __forceinline Vec3fa sign ( const Vec3fa& a ) { … }

  __forceinline Vec3fa rcp  ( const Vec3fa& a )
  { … }

  __forceinline Vec3fa sqrt ( const Vec3fa& a ) { … }
  __forceinline Vec3fa sqr  ( const Vec3fa& a ) { … }

  __forceinline Vec3fa rsqrt( const Vec3fa& a )
  { … }

  __forceinline Vec3fa zero_fix(const Vec3fa& a) { … }
  __forceinline Vec3fa rcp_safe(const Vec3fa& a) { … }
  __forceinline Vec3fa log ( const Vec3fa& a ) { … }

  __forceinline Vec3fa exp ( const Vec3fa& a ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Binary Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fa operator +( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa operator -( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa operator *( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa operator *( const Vec3fa& a, const float b ) { … }
  __forceinline Vec3fa operator *( const float a, const Vec3fa& b ) { … }
  __forceinline Vec3fa operator /( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa operator /( const Vec3fa& a, const float b        ) { … }
  __forceinline Vec3fa operator /( const        float a, const Vec3fa& b ) { … }

  __forceinline Vec3fa min( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa max( const Vec3fa& a, const Vec3fa& b ) { … }

#if defined(__aarch64__) || defined(__SSE4_1__)
    __forceinline Vec3fa mini(const Vec3fa& a, const Vec3fa& b) {
      const vint4 ai = _mm_castps_si128(a.m128);
      const vint4 bi = _mm_castps_si128(b.m128);
      const vint4 ci = _mm_min_epi32(ai,bi);
      return _mm_castsi128_ps(ci);
    }
#endif

#if defined(__aarch64__) || defined(__SSE4_1__)
    __forceinline Vec3fa maxi(const Vec3fa& a, const Vec3fa& b) {
      const vint4 ai = _mm_castps_si128(a.m128);
      const vint4 bi = _mm_castps_si128(b.m128);
      const vint4 ci = _mm_max_epi32(ai,bi);
      return _mm_castsi128_ps(ci);
    }
#endif

    __forceinline Vec3fa pow ( const Vec3fa& a, const float& b ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Ternary Operators
  ////////////////////////////////////////////////////////////////////////////////

#if defined(__AVX2__) || defined(__ARM_NEON)
  __forceinline Vec3fa madd  ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { return _mm_fmadd_ps(a.m128,b.m128,c.m128); }
  __forceinline Vec3fa msub  ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { return _mm_fmsub_ps(a.m128,b.m128,c.m128); }
  __forceinline Vec3fa nmadd ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { return _mm_fnmadd_ps(a.m128,b.m128,c.m128); }
  __forceinline Vec3fa nmsub ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { return _mm_fnmsub_ps(a.m128,b.m128,c.m128); }
#else
  __forceinline Vec3fa madd  ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { … }
  __forceinline Vec3fa nmadd ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { … }
  __forceinline Vec3fa nmsub ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { … }
  __forceinline Vec3fa msub  ( const Vec3fa& a, const Vec3fa& b, const Vec3fa& c) { … }
#endif

  __forceinline Vec3fa madd  ( const float a, const Vec3fa& b, const Vec3fa& c) { … }
  __forceinline Vec3fa msub  ( const float a, const Vec3fa& b, const Vec3fa& c) { … }
  __forceinline Vec3fa nmadd ( const float a, const Vec3fa& b, const Vec3fa& c) { … }
  __forceinline Vec3fa nmsub ( const float a, const Vec3fa& b, const Vec3fa& c) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Assignment Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fa& operator +=( Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa& operator -=( Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa& operator *=( Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa& operator *=( Vec3fa& a, const float   b ) { … }
  __forceinline Vec3fa& operator /=( Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3fa& operator /=( Vec3fa& a, const float   b ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Reductions
  ////////////////////////////////////////////////////////////////////////////////
#if defined(__aarch64__)
  __forceinline float reduce_add(const Vec3fa& v) {
    float32x4_t t = v.m128;
    t[3] = 0.0f;
    return vaddvq_f32(t);
  }

  __forceinline float reduce_mul(const Vec3fa& v) { return v.x*v.y*v.z; }
  __forceinline float reduce_min(const Vec3fa& v) {
    float32x4_t t = v.m128;
      t[3] = t[2];
    return vminvq_f32(t);
  }
  __forceinline float reduce_max(const Vec3fa& v) {
    float32x4_t t = v.m128;
      t[3] = t[2];
    return vmaxvq_f32(t);
  }
#else
  __forceinline float reduce_add(const Vec3fa& v) { … }

  __forceinline float reduce_mul(const Vec3fa& v) { … }
  __forceinline float reduce_min(const Vec3fa& v) { … }
  __forceinline float reduce_max(const Vec3fa& v) { … }
#endif

  ////////////////////////////////////////////////////////////////////////////////
  /// Comparison Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline bool operator ==( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline bool operator !=( const Vec3fa& a, const Vec3fa& b ) { … }

  __forceinline Vec3ba eq_mask( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3ba neq_mask(const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3ba lt_mask( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline Vec3ba le_mask( const Vec3fa& a, const Vec3fa& b ) { … }
 #if defined(__aarch64__)
  __forceinline Vec3ba gt_mask( const Vec3fa& a, const Vec3fa& b ) { return _mm_cmpgt_ps (a.m128, b.m128); }
  __forceinline Vec3ba ge_mask( const Vec3fa& a, const Vec3fa& b ) { return _mm_cmpge_ps (a.m128, b.m128); }
#else
  __forceinline Vec3ba gt_mask(const Vec3fa& a, const Vec3fa& b) { … }
  __forceinline Vec3ba ge_mask(const Vec3fa& a, const Vec3fa& b) { … }
#endif

  __forceinline bool isvalid ( const Vec3fa& v ) { … }

  __forceinline bool is_finite ( const Vec3fa& a ) { … }

  __forceinline bool isvalid4 ( const Vec3fa& v ) { … }

  __forceinline bool is_finite4 ( const Vec3fa& a ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Euclidean Space Operators
  ////////////////////////////////////////////////////////////////////////////////

#if defined(__SSE4_1__)
  __forceinline float dot ( const Vec3fa& a, const Vec3fa& b ) {
    return _mm_cvtss_f32(_mm_dp_ps(a.m128,b.m128,0x7F));
  }
#else
  __forceinline float dot ( const Vec3fa& a, const Vec3fa& b ) { … }
#endif

  __forceinline Vec3fa cross ( const Vec3fa& a, const Vec3fa& b )
  { … }

  __forceinline float  sqr_length ( const Vec3fa& a )                { … }
  __forceinline float  rcp_length ( const Vec3fa& a )                { … }
  __forceinline float  rcp_length2( const Vec3fa& a )                { … }
  __forceinline float  length   ( const Vec3fa& a )                  { … }
  __forceinline Vec3fa normalize( const Vec3fa& a )                  { … }
  __forceinline float  distance ( const Vec3fa& a, const Vec3fa& b ) { … }
  __forceinline float  halfArea ( const Vec3fa& d )                  { … }
  __forceinline float  area     ( const Vec3fa& d )                  { … }

  __forceinline Vec3fa normalize_safe( const Vec3fa& a ) { … }

  /*! differentiated normalization */
  __forceinline Vec3fa dnormalize(const Vec3fa& p, const Vec3fa& dp)
  { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Select
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fa select( bool s, const Vec3fa& t, const Vec3fa& f ) { … }

  __forceinline Vec3fa select( const Vec3ba& s, const Vec3fa& t, const Vec3fa& f ) { … }

  __forceinline Vec3fa lerp(const Vec3fa& v0, const Vec3fa& v1, const float t) { … }

  __forceinline int maxDim ( const Vec3fa& a )
  { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Rounding Functions
  ////////////////////////////////////////////////////////////////////////////////

#if defined(__aarch64__)
  __forceinline Vec3fa floor(const Vec3fa& a) { return vrndmq_f32(a.m128); }
  __forceinline Vec3fa ceil (const Vec3fa& a) { return vrndpq_f32(a.m128); }
  __forceinline Vec3fa trunc(const Vec3fa& a) { return vrndq_f32(a.m128); }
#elif defined (__SSE4_1__)
  __forceinline Vec3fa trunc( const Vec3fa& a ) { return _mm_round_ps(a.m128, _MM_FROUND_TO_NEAREST_INT); }
  __forceinline Vec3fa floor( const Vec3fa& a ) { return _mm_round_ps(a.m128, _MM_FROUND_TO_NEG_INF    ); }
  __forceinline Vec3fa ceil ( const Vec3fa& a ) { return _mm_round_ps(a.m128, _MM_FROUND_TO_POS_INF    ); }
#else
  __forceinline Vec3fa trunc( const Vec3fa& a ) { … }
  __forceinline Vec3fa floor( const Vec3fa& a ) { … }
  __forceinline Vec3fa ceil ( const Vec3fa& a ) { … }
#endif

  ////////////////////////////////////////////////////////////////////////////////
  /// Output Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline embree_ostream operator<<(embree_ostream cout, const Vec3fa& a) { … }

  Vec3fa_t;


  ////////////////////////////////////////////////////////////////////////////////
  /// SSE Vec3fx Type
  ////////////////////////////////////////////////////////////////////////////////

  struct __aligned(16) Vec3fx
  { … };

  ////////////////////////////////////////////////////////////////////////////////
  /// Unary Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fx operator +( const Vec3fx& a ) { … }
  __forceinline Vec3fx operator -( const Vec3fx& a ) { … }
  __forceinline Vec3fx abs  ( const Vec3fx& a ) { … }
  __forceinline Vec3fx sign ( const Vec3fx& a ) { … }

  __forceinline Vec3fx rcp  ( const Vec3fx& a )
  { … }

  __forceinline Vec3fx sqrt ( const Vec3fx& a ) { … }
  __forceinline Vec3fx sqr  ( const Vec3fx& a ) { … }

  __forceinline Vec3fx rsqrt( const Vec3fx& a )
  { … }

  __forceinline Vec3fx zero_fix(const Vec3fx& a) { … }
  __forceinline Vec3fx rcp_safe(const Vec3fx& a) { … }
  __forceinline Vec3fx log ( const Vec3fx& a ) { … }

  __forceinline Vec3fx exp ( const Vec3fx& a ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Binary Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fx operator +( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx operator -( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx operator *( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx operator *( const Vec3fx& a, const float b ) { … }
  __forceinline Vec3fx operator *( const float a, const Vec3fx& b ) { … }
  __forceinline Vec3fx operator /( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx operator /( const Vec3fx& a, const float b        ) { … }
  __forceinline Vec3fx operator /( const        float a, const Vec3fx& b ) { … }

  __forceinline Vec3fx min( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx max( const Vec3fx& a, const Vec3fx& b ) { … }

#if defined(__SSE4_1__) || defined(__aarch64__)
    __forceinline Vec3fx mini(const Vec3fx& a, const Vec3fx& b) {
      const vint4 ai = _mm_castps_si128(a.m128);
      const vint4 bi = _mm_castps_si128(b.m128);
      const vint4 ci = _mm_min_epi32(ai,bi);
      return _mm_castsi128_ps(ci);
    }
#endif

#if defined(__SSE4_1__) || defined(__aarch64__)
    __forceinline Vec3fx maxi(const Vec3fx& a, const Vec3fx& b) {
      const vint4 ai = _mm_castps_si128(a.m128);
      const vint4 bi = _mm_castps_si128(b.m128);
      const vint4 ci = _mm_max_epi32(ai,bi);
      return _mm_castsi128_ps(ci);
    }
#endif

    __forceinline Vec3fx pow ( const Vec3fx& a, const float& b ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Ternary Operators
  ////////////////////////////////////////////////////////////////////////////////

#if defined(__AVX2__)
  __forceinline Vec3fx madd  ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { return _mm_fmadd_ps(a.m128,b.m128,c.m128); }
  __forceinline Vec3fx msub  ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { return _mm_fmsub_ps(a.m128,b.m128,c.m128); }
  __forceinline Vec3fx nmadd ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { return _mm_fnmadd_ps(a.m128,b.m128,c.m128); }
  __forceinline Vec3fx nmsub ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { return _mm_fnmsub_ps(a.m128,b.m128,c.m128); }
#else
  __forceinline Vec3fx madd  ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { … }
  __forceinline Vec3fx msub  ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { … }
  __forceinline Vec3fx nmadd ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { … }
  __forceinline Vec3fx nmsub ( const Vec3fx& a, const Vec3fx& b, const Vec3fx& c) { … }
#endif

  __forceinline Vec3fx madd  ( const float a, const Vec3fx& b, const Vec3fx& c) { … }
  __forceinline Vec3fx msub  ( const float a, const Vec3fx& b, const Vec3fx& c) { … }
  __forceinline Vec3fx nmadd ( const float a, const Vec3fx& b, const Vec3fx& c) { … }
  __forceinline Vec3fx nmsub ( const float a, const Vec3fx& b, const Vec3fx& c) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Assignment Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fx& operator +=( Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx& operator -=( Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx& operator *=( Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx& operator *=( Vec3fx& a, const float   b ) { … }
  __forceinline Vec3fx& operator /=( Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3fx& operator /=( Vec3fx& a, const float   b ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Reductions
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline float reduce_add(const Vec3fx& v) { … }

  __forceinline float reduce_mul(const Vec3fx& v) { … }
  __forceinline float reduce_min(const Vec3fx& v) { … }
  __forceinline float reduce_max(const Vec3fx& v) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Comparison Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline bool operator ==( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline bool operator !=( const Vec3fx& a, const Vec3fx& b ) { … }

  __forceinline Vec3ba eq_mask( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3ba neq_mask(const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3ba lt_mask( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3ba le_mask( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3ba gt_mask( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline Vec3ba ge_mask( const Vec3fx& a, const Vec3fx& b ) { … }

  __forceinline bool isvalid ( const Vec3fx& v ) { … }

  __forceinline bool is_finite ( const Vec3fx& a ) { … }

  __forceinline bool isvalid4 ( const Vec3fx& v ) { … }

  __forceinline bool is_finite4 ( const Vec3fx& a ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Euclidean Space Operators
  ////////////////////////////////////////////////////////////////////////////////

#if defined(__SSE4_1__)
  __forceinline float dot ( const Vec3fx& a, const Vec3fx& b ) {
    return _mm_cvtss_f32(_mm_dp_ps(a.m128,b.m128,0x7F));
  }
#else
  __forceinline float dot ( const Vec3fx& a, const Vec3fx& b ) { … }
#endif

  __forceinline Vec3fx cross ( const Vec3fx& a, const Vec3fx& b )
  { … }

  __forceinline float  sqr_length ( const Vec3fx& a )                { … }
  __forceinline float  rcp_length ( const Vec3fx& a )                { … }
  __forceinline float  rcp_length2( const Vec3fx& a )                { … }
  __forceinline float  length   ( const Vec3fx& a )                  { … }
  __forceinline Vec3fx normalize( const Vec3fx& a )                  { … }
  __forceinline float  distance ( const Vec3fx& a, const Vec3fx& b ) { … }
  __forceinline float  halfArea ( const Vec3fx& d )                  { … }
  __forceinline float  area     ( const Vec3fx& d )                  { … }

  __forceinline Vec3fx normalize_safe( const Vec3fx& a ) { … }

  /*! differentiated normalization */
  __forceinline Vec3fx dnormalize(const Vec3fx& p, const Vec3fx& dp)
  { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Select
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline Vec3fx select( bool s, const Vec3fx& t, const Vec3fx& f ) { … }

  __forceinline Vec3fx select( const Vec3ba& s, const Vec3fx& t, const Vec3fx& f ) { … }

  __forceinline Vec3fx lerp(const Vec3fx& v0, const Vec3fx& v1, const float t) { … }

  __forceinline int maxDim ( const Vec3fx& a )
  { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Rounding Functions
  ////////////////////////////////////////////////////////////////////////////////

#if defined(__aarch64__)
  __forceinline Vec3fx trunc(const Vec3fx& a) { return vrndq_f32(a.m128); }
  __forceinline Vec3fx floor(const Vec3fx& a) { return vrndmq_f32(a.m128); }
  __forceinline Vec3fx ceil (const Vec3fx& a) { return vrndpq_f32(a.m128); }
#elif defined (__SSE4_1__)
  __forceinline Vec3fx trunc( const Vec3fx& a ) { return _mm_round_ps(a.m128, _MM_FROUND_TO_NEAREST_INT); }
  __forceinline Vec3fx floor( const Vec3fx& a ) { return _mm_round_ps(a.m128, _MM_FROUND_TO_NEG_INF    ); }
  __forceinline Vec3fx ceil ( const Vec3fx& a ) { return _mm_round_ps(a.m128, _MM_FROUND_TO_POS_INF    ); }
#else
  __forceinline Vec3fx trunc( const Vec3fx& a ) { … }
  __forceinline Vec3fx floor( const Vec3fx& a ) { … }
  __forceinline Vec3fx ceil ( const Vec3fx& a ) { … }
#endif

  ////////////////////////////////////////////////////////////////////////////////
  /// Output Operators
  ////////////////////////////////////////////////////////////////////////////////

  __forceinline embree_ostream operator<<(embree_ostream cout, const Vec3fx& a) { … }

  
  Vec3ff;
}

#endif
godot/thirdparty/embree/common/math/vec3fa.h
