vec2fa.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 "vec2fa_sycl.h"
#else

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

namespace embree
{
  ////////////////////////////////////////////////////////////////////////////////
  /// SSE Vec2fa Type
  ////////////////////////////////////////////////////////////////////////////////

  struct __aligned(16) Vec2fa
  { … };

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

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

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

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

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

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

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

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

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

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

#if defined(__aarch64__) || defined(__SSE4_1__)
    __forceinline Vec2fa mini(const Vec2fa& a, const Vec2fa& b) {
      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(__SSE4_1__)
    __forceinline Vec2fa maxi(const Vec2fa& a, const Vec2fa& b) {
      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

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

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

#if defined(__AVX2__)
  __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) { … }
  __forceinline Vec2fa msub  ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { … }
  __forceinline Vec2fa nmadd ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { … }
  __forceinline Vec2fa nmsub ( const Vec2fa& a, const Vec2fa& b, const Vec2fa& c) { … }
#endif

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

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

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

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

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

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

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

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

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

  __forceinline Vec2fa cross ( const Vec2fa& a ) { … }

  __forceinline float  sqr_length ( const Vec2fa& a )                { … }
  __forceinline float  rcp_length ( const Vec2fa& a )                { … }
  __forceinline float  rcp_length2( const Vec2fa& a )                { … }
  __forceinline float  length   ( const Vec2fa& a )                  { … }
  __forceinline Vec2fa normalize( const Vec2fa& a )                  { … }
  __forceinline float  distance ( const Vec2fa& a, const Vec2fa& b ) { … }

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

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

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

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

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

#if defined(__aarch64__)
  //__forceinline Vec2fa trunc(const Vec2fa& a) { return vrndq_f32(a); }
  __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, _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 ) { … }
  __forceinline Vec2fa ceil ( const Vec2fa& a ) { … }
#endif

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

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

  Vec2fa_t;
}

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