vec4.h | Explore in Territory

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

#pragma once

#include "emath.h"
#include "vec3.h"

namespace embree
{
  ////////////////////////////////////////////////////////////////////////////////
  /// Generic 4D vector Class
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> struct Vec4
  { … };

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

  template<typename T> __forceinline Vec4<T> operator +( const Vec4<T>& a ) { … }
  template<typename T> __forceinline Vec4<T> operator -( const Vec4<T>& a ) { … }
  template<typename T> __forceinline Vec4<T> abs       ( const Vec4<T>& a ) { … }
  template<typename T> __forceinline Vec4<T> rcp       ( const Vec4<T>& a ) { … }
  template<typename T> __forceinline Vec4<T> rsqrt     ( const Vec4<T>& a ) { … }
  template<typename T> __forceinline Vec4<T> sqrt      ( const Vec4<T>& a ) { … }

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

  template<typename T> __forceinline Vec4<T> operator +( const Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T> operator -( const Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T> operator *( const Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T> operator *( const       T& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T> operator *( const Vec4<T>& a, const       T& b ) { … }
  template<typename T> __forceinline Vec4<T> operator /( const Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T> operator /( const Vec4<T>& a, const       T& b ) { … }
  template<typename T> __forceinline Vec4<T> operator /( const       T& a, const Vec4<T>& b ) { … }

  template<typename T> __forceinline Vec4<T> min(const Vec4<T>& a, const Vec4<T>& b) { … }
  template<typename T> __forceinline Vec4<T> max(const Vec4<T>& a, const Vec4<T>& b) { … }

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

  template<typename T> __forceinline Vec4<T> madd  ( const Vec4<T>& a, const Vec4<T>& b, const Vec4<T>& c) { … }
  template<typename T> __forceinline Vec4<T> msub  ( const Vec4<T>& a, const Vec4<T>& b, const Vec4<T>& c) { … }
  template<typename T> __forceinline Vec4<T> nmadd ( const Vec4<T>& a, const Vec4<T>& b, const Vec4<T>& c) { … }
  template<typename T> __forceinline Vec4<T> nmsub ( const Vec4<T>& a, const Vec4<T>& b, const Vec4<T>& c) { … }

  template<typename T> __forceinline Vec4<T> madd  ( const T& a, const Vec4<T>& b, const Vec4<T>& c) { … }
  template<typename T> __forceinline Vec4<T> msub  ( const T& a, const Vec4<T>& b, const Vec4<T>& c) { … }
  template<typename T> __forceinline Vec4<T> nmadd ( const T& a, const Vec4<T>& b, const Vec4<T>& c) { … }
  template<typename T> __forceinline Vec4<T> nmsub ( const T& a, const Vec4<T>& b, const Vec4<T>& c) { … }

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

  template<typename T> __forceinline Vec4<T>& operator +=( Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T>& operator -=( Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline Vec4<T>& operator *=( Vec4<T>& a, const       T& b ) { … }
  template<typename T> __forceinline Vec4<T>& operator /=( Vec4<T>& a, const       T& b ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Reduction Operators
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> __forceinline T reduce_add( const Vec4<T>& a ) { … }
  template<typename T> __forceinline T reduce_mul( const Vec4<T>& a ) { … }
  template<typename T> __forceinline T reduce_min( const Vec4<T>& a ) { … }
  template<typename T> __forceinline T reduce_max( const Vec4<T>& a ) { … }

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

  template<typename T> __forceinline bool operator ==( const Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline bool operator !=( const Vec4<T>& a, const Vec4<T>& b ) { … }
  template<typename T> __forceinline bool operator < ( const Vec4<T>& a, const Vec4<T>& b ) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Shift Operators
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> __forceinline Vec4<T> shift_right_1( const Vec4<T>& a ) { … }

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

  template<typename T> __forceinline T       dot      ( const Vec4<T>& a, const Vec4<T>& b ) { … }

  template<typename T> __forceinline T       length   ( const Vec4<T>& a )                   { … }
  template<typename T> __forceinline Vec4<T> normalize( const Vec4<T>& a )                   { … }
  template<typename T> __forceinline T       distance ( const Vec4<T>& a, const Vec4<T>& b ) { … }

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

  template<typename T> __forceinline Vec4<T> select ( bool s, const Vec4<T>& t, const Vec4<T>& f ) { … }

  template<typename T> __forceinline Vec4<T> select ( const Vec4<bool>& s, const Vec4<T>& t, const Vec4<T>& f ) { … }

  template<typename T> __forceinline Vec4<T> select ( const typename T::Bool& s, const Vec4<T>& t, const Vec4<T>& f ) { … }

  template<typename T>
    __forceinline Vec4<T> lerp(const Vec4<T>& v0, const Vec4<T>& v1, const T& t) { … }

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

  template<typename T> __forceinline embree_ostream operator<<(embree_ostream cout, const Vec4<T>& a) { … }

  ////////////////////////////////////////////////////////////////////////////////
  /// Default template instantiations
  ////////////////////////////////////////////////////////////////////////////////

  Vec4b;
  Vec4uc;
  Vec4i;
  Vec4f;
}

#include "vec3ba.h"
#include "vec3ia.h"
#include "vec3fa.h"

////////////////////////////////////////////////////////////////////////////////
/// SSE / AVX / MIC specializations
////////////////////////////////////////////////////////////////////////////////

#if defined(__SSE__) || defined(__ARM_NEON)
#include "../simd/sse.h"
#endif

#if defined __AVX__
#include "../simd/avx.h"
#endif

#if defined __AVX512F__
#include "../simd/avx512.h"
#endif

namespace embree
{
  template<> __forceinline Vec4<float>::Vec4( const Vec3fx& a ) { … }

#if !defined(__SYCL_DEVICE_ONLY__)

#if defined(__AVX__)
  template<> __forceinline Vec4<vfloat4>::Vec4( const Vec3fx& a ) {
    x = a.x; y = a.y; z = a.z; w = a.w;
  }
#elif defined(__SSE__) || defined(__ARM_NEON)
  template<> __forceinline Vec4<vfloat4>::Vec4( const Vec3fx& a ) { … }
#endif

#if defined(__AVX__)
  template<> __forceinline Vec4<vfloat8>::Vec4( const Vec3fx& a ) {
    x = a.x; y = a.y; z = a.z; w = a.w;
  }
#endif

#if defined(__AVX512F__)
  template<> __forceinline Vec4<vfloat16>::Vec4( const Vec3fx& a ) : x(a.x), y(a.y), z(a.z), w(a.w) {}
#endif

#else

#if defined(__SSE__)
  template<> __forceinline Vec4<vfloat4>::Vec4(const Vec3fx& a) {
    x = a.x; y = a.y; z = a.z; w = a.w;
  }
#endif
#if defined(__AVX__)
  template<> __forceinline Vec4<vfloat8>::Vec4(const Vec3fx& a) {
    x = a.x; y = a.y; z = a.z; w = a.w;
  }
#endif
#if defined(__AVX512F__)
  template<> __forceinline Vec4<vfloat16>::Vec4(const Vec3fx& a) {
    x = a.x; y = a.y; z = a.z; w = a.w;
  }
#endif
  
#endif
}
godot/thirdparty/embree/common/math/vec4.h
