godot/thirdparty/embree/common/math/linearspace3.h

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

#pragma once

#include "vec3.h"
#include "quaternion.h"

namespace embree
{
  ////////////////////////////////////////////////////////////////////////////////
  /// 3D Linear Transform (3x3 Matrix)
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> struct LinearSpace3
  { … };

#if !defined(__SYCL_DEVICE_ONLY__)
  
  /*! compute transposed matrix */
  template<> __forceinline const LinearSpace3<Vec3fa> LinearSpace3<Vec3fa>::transposed() const { … }
#endif
  
  template<typename T>
    __forceinline const LinearSpace3<T> transposed(const LinearSpace3<T>& xfm) { … }
  
  ////////////////////////////////////////////////////////////////////////////////
  // Unary Operators
  ////////////////////////////////////////////////////////////////////////////////

  template<typename T> __forceinline LinearSpace3<T> operator -( const LinearSpace3<T>& a ) { … }
  template<typename T> __forceinline LinearSpace3<T> operator +( const LinearSpace3<T>& a ) { … }
  template<typename T> __forceinline LinearSpace3<T> rcp       ( const LinearSpace3<T>& a ) { … }

  /* constructs a coordinate frame form a normalized normal */
  template<typename T> __forceinline LinearSpace3<T> frame(const T& N) 
  { … }

  /* constructs a coordinate frame from a normal and approximate x-direction */
  template<typename T> __forceinline LinearSpace3<T> frame(const T& N, const T& dxi)
  { … }
  
  /* clamps linear space to range -1 to +1 */
  template<typename T> __forceinline LinearSpace3<T> clamp(const LinearSpace3<T>& space) { … }

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

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

  template<typename T> __forceinline LinearSpace3<T> operator*(const typename T::Scalar & a, const LinearSpace3<T>& b) { … }
  template<typename T> __forceinline T               operator*(const LinearSpace3<T>& a, const T              & b) { … }
  template<typename T> __forceinline LinearSpace3<T> operator*(const LinearSpace3<T>& a, const LinearSpace3<T>& b) { … }

  template<typename T> __forceinline LinearSpace3<T> operator/(const LinearSpace3<T>& a, const typename T::Scalar & b) { … }
  template<typename T> __forceinline LinearSpace3<T> operator/(const LinearSpace3<T>& a, const LinearSpace3<T>& b) { … }

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

  template<typename T> __forceinline T       xfmPoint (const LinearSpace3<T>& s, const T      & a) { … }
  template<typename T> __forceinline T       xfmVector(const LinearSpace3<T>& s, const T      & a) { … }
  template<typename T> __forceinline T       xfmNormal(const LinearSpace3<T>& s, const T      & a) { … }

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

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

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

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

  /*! blending */
  template<typename T>
    __forceinline LinearSpace3<T> lerp(const LinearSpace3<T>& l0, const LinearSpace3<T>& l1, const float t) 
  { … }

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

  template<typename T> static embree_ostream operator<<(embree_ostream cout, const LinearSpace3<T>& m) { … }

  /*! Shortcuts for common linear spaces. */
  LinearSpace3f;
  LinearSpace3fa;
  LinearSpace3fx;
  LinearSpace3ff;

  LinearSpace3vf;
  LinearSpace3vf4;
  LinearSpace3vf8;
  LinearSpace3vf16;

  /*! blending */
  template<typename T, typename S>
    __forceinline LinearSpace3<T> lerp(const LinearSpace3<T>& l0,
                                       const LinearSpace3<T>& l1,
                                       const S& t)
  { … }

}