vec2.h | Explore in Territory

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

#pragma once

#include "emath.h"

namespace embree
{
  struct Vec2fa;
  
  ////////////////////////////////////////////////////////////////////////////////
  /// Generic 2D vector Class
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> struct Vec2
  { … };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  template<typename T> __forceinline Vec2<T> shift_right_1( const Vec2<T>& a ) { … }
  
  ////////////////////////////////////////////////////////////////////////////////
  /// Euclidean Space Operators
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> __forceinline T       dot      ( const Vec2<T>& a, const Vec2<T>& b ) { … }
  template<typename T> __forceinline Vec2<T> cross    ( const Vec2<T>& a )                   { … } 
  template<typename T> __forceinline T       length   ( const Vec2<T>& a )                   { … }
  template<typename T> __forceinline Vec2<T> normalize( const Vec2<T>& a )                   { … }
  template<typename T> __forceinline T       distance ( const Vec2<T>& a, const Vec2<T>& b ) { … }
  template<typename T> __forceinline T       det      ( const Vec2<T>& a, const Vec2<T>& b ) { … }

  template<typename T> __forceinline Vec2<T> normalize_safe( const Vec2<T>& a ) { … }

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

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

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

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

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

  template<typename T> __forceinline int maxDim ( const Vec2<T>& a )
  { … }

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

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

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

  Vec2b;
  Vec2i;
  Vec2f;
}

#include "vec2fa.h"

#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 Vec2<float>::Vec2(const Vec2fa& a) : … { … }

#if defined(__SSE__) || defined(__ARM_NEON)
  template<> __forceinline Vec2<vfloat4>::Vec2(const Vec2fa& a) : … { … }
#endif

#if defined(__AVX__)
  template<> __forceinline Vec2<vfloat8>::Vec2(const Vec2fa& a) : x(a.x), y(a.y) {}
#endif

#if defined(__AVX512F__)
  template<> __forceinline Vec2<vfloat16>::Vec2(const Vec2fa& a) : x(a.x), y(a.y) {}
#endif

}
godot/thirdparty/embree/common/math/vec2.h
