kc3-lang/angle/src/common/vector_utils.h

• Show log

  Commit

• Hash : a971e5b4
  Author :
  Date : 2024-02-28T17:13:38
  

  Account for zero vector axes in Mat4::Rotate(...)
  
  When the axis passed in to the Rotate function is (0, 0, 0), normalizing
  that vector will result in NaN values. Prevent this by returning an
  identity matrix and early out instead.
  
  Bug: angleproject:2306
  Tests: MatrixBuiltinsTest.RotateAxisZero
  Change-Id: I65fd0b9944885daf56a4a35201d424e7f0aa9ba6
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5333834
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/common/vector_utils.h

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // vector_utils.h: Utility classes implementing various vector operations
  
  #ifndef COMMON_VECTOR_UTILS_H_
  #define COMMON_VECTOR_UTILS_H_
  
  #include <cmath>
  #include <cstddef>
  #include <ostream>
  #include <type_traits>
  #include "common/debug.h"
  
  namespace angle
  {
  
  template <size_t Dimension, typename Type>
  class Vector;
  
  using Vector2 = Vector<2, float>;
  using Vector3 = Vector<3, float>;
  using Vector4 = Vector<4, float>;
  
  using Vector2I = Vector<2, int>;
  using Vector3I = Vector<3, int>;
  using Vector4I = Vector<4, int>;
  
  using Vector2U = Vector<2, unsigned int>;
  using Vector3U = Vector<3, unsigned int>;
  using Vector4U = Vector<4, unsigned int>;
  
  template <size_t Dimension, typename Type>
  class VectorBase
  {
    public:
      using VectorN = Vector<Dimension, Type>;
  
      // Constructors
      VectorBase() = default;
      explicit VectorBase(Type element);
  
      template <typename Type2>
      VectorBase(const VectorBase<Dimension, Type2> &other);
  
      template <typename Arg1, typename Arg2, typename... Args>
      VectorBase(const Arg1 &arg1, const Arg2 &arg2, const Args &...args);
  
      // Access the vector backing storage directly
      const Type *data() const { return mData; }
      Type *data() { return mData; }
      constexpr size_t size() const { return Dimension; }
  
      // Load or store the pointer from / to raw data
      static VectorN Load(const Type *source);
      static void Store(const VectorN &source, Type *destination);
  
      // Index the vector
      Type &operator[](size_t i) { return mData[i]; }
      const Type &operator[](size_t i) const { return mData[i]; }
  
      // Basic arithmetic operations
      VectorN operator+() const;
      VectorN operator-() const;
      VectorN operator+(const VectorN &other) const;
      VectorN operator-(const VectorN &other) const;
      VectorN operator*(const VectorN &other) const;
      VectorN operator/(const VectorN &other) const;
      VectorN operator*(Type other) const;
      VectorN operator/(Type other) const;
      friend VectorN operator*(Type a, const VectorN &b) { return b * a; }
  
      // Compound arithmetic operations
      VectorN &operator+=(const VectorN &other);
      VectorN &operator-=(const VectorN &other);
      VectorN &operator*=(const VectorN &other);
      VectorN &operator/=(const VectorN &other);
      VectorN &operator*=(Type other);
      VectorN &operator/=(Type other);
  
      // Comparison operators
      bool operator==(const VectorBase<Dimension, Type> &other) const;
      bool operator!=(const VectorBase<Dimension, Type> &other) const;
  
      // Other arithmetic operations
      Type length() const;
      Type lengthSquared() const;
      Type dot(const VectorBase<Dimension, Type> &other) const;
      VectorN normalized() const;
  
    protected:
      template <size_t CurrentIndex, size_t OtherDimension, typename OtherType, typename... Args>
      void initWithList(const Vector<OtherDimension, OtherType> &arg1, const Args &...args);
  
      // Some old compilers consider this function an alternative for initWithList(Vector)
      // when the variant above is more precise. Use SFINAE on the return value to hide
      // this variant for non-arithmetic types. The return value is still void.
      template <size_t CurrentIndex, typename OtherType, typename... Args>
      typename std::enable_if<std::is_arithmetic<OtherType>::value>::type initWithList(
          OtherType arg1,
          const Args &...args);
  
      template <size_t CurrentIndex>
      void initWithList() const;
  
      template <size_t Dimension2, typename Type2>
      friend class VectorBase;
  
      Type mData[Dimension];
  };
  
  template <size_t Dimension, typename Type>
  std::ostream &operator<<(std::ostream &ostream, const VectorBase<Dimension, Type> &vector);
  
  template <typename Type>
  class Vector<2, Type> : public VectorBase<2, Type>
  {
    public:
      // Import the constructors defined in VectorBase
      using VectorBase<2, Type>::VectorBase;
  
      // Element shorthands
      Type &x() { return this->mData[0]; }
      Type &y() { return this->mData[1]; }
  
      const Type &x() const { return this->mData[0]; }
      const Type &y() const { return this->mData[1]; }
  };
  
  template <typename Type>
  std::ostream &operator<<(std::ostream &ostream, const Vector<2, Type> &vector);
  
  template <typename Type>
  class Vector<3, Type> : public VectorBase<3, Type>
  {
    public:
      // Import the constructors defined in VectorBase
      using VectorBase<3, Type>::VectorBase;
  
      // Additional operations
      Vector<3, Type> cross(const Vector<3, Type> &other) const;
  
      // Element shorthands
      Type &x() { return this->mData[0]; }
      Type &y() { return this->mData[1]; }
      Type &z() { return this->mData[2]; }
  
      const Type &x() const { return this->mData[0]; }
      const Type &y() const { return this->mData[1]; }
      const Type &z() const { return this->mData[2]; }
  };
  
  template <typename Type>
  std::ostream &operator<<(std::ostream &ostream, const Vector<3, Type> &vector);
  
  template <typename Type>
  class Vector<4, Type> : public VectorBase<4, Type>
  {
    public:
      // Import the constructors defined in VectorBase
      using VectorBase<4, Type>::VectorBase;
  
      // Element shorthands
      Type &x() { return this->mData[0]; }
      Type &y() { return this->mData[1]; }
      Type &z() { return this->mData[2]; }
      Type &w() { return this->mData[3]; }
  
      const Type &x() const { return this->mData[0]; }
      const Type &y() const { return this->mData[1]; }
      const Type &z() const { return this->mData[2]; }
      const Type &w() const { return this->mData[3]; }
  };
  
  template <typename Type>
  std::ostream &operator<<(std::ostream &ostream, const Vector<4, Type> &vector);
  
  // Implementation of constructors and misc operations
  
  template <size_t Dimension, typename Type>
  VectorBase<Dimension, Type>::VectorBase(Type element)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] = element;
      }
  }
  
  template <size_t Dimension, typename Type>
  template <typename Type2>
  VectorBase<Dimension, Type>::VectorBase(const VectorBase<Dimension, Type2> &other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] = static_cast<Type>(other.mData[i]);
      }
  }
  
  // Ideally we would like to have only two constructors:
  //  - a scalar constructor that takes Type as a parameter
  //  - a compound constructor
  // However if we define the compound constructor for when it has a single arguments, then calling
  // Vector2(0.0) will be ambiguous. To solve this we take advantage of there being a single compound
  // constructor with a single argument, which is the copy constructor. We end up with three
  // constructors:
  //  - the scalar constructor
  //  - the copy constructor
  //  - the compound constructor for two or more arguments, hence the arg1, and arg2 here.
  template <size_t Dimension, typename Type>
  template <typename Arg1, typename Arg2, typename... Args>
  VectorBase<Dimension, Type>::VectorBase(const Arg1 &arg1, const Arg2 &arg2, const Args &...args)
  {
      initWithList<0>(arg1, arg2, args...);
  }
  
  template <size_t Dimension, typename Type>
  template <size_t CurrentIndex, size_t OtherDimension, typename OtherType, typename... Args>
  void VectorBase<Dimension, Type>::initWithList(const Vector<OtherDimension, OtherType> &arg1,
                                                 const Args &...args)
  {
      static_assert(CurrentIndex + OtherDimension <= Dimension,
                    "Too much data in the vector constructor.");
      for (size_t i = 0; i < OtherDimension; ++i)
      {
          mData[CurrentIndex + i] = static_cast<Type>(arg1.mData[i]);
      }
      initWithList<CurrentIndex + OtherDimension>(args...);
  }
  
  template <size_t Dimension, typename Type>
  template <size_t CurrentIndex, typename OtherType, typename... Args>
  typename std::enable_if<std::is_arithmetic<OtherType>::value>::type
  VectorBase<Dimension, Type>::initWithList(OtherType arg1, const Args &...args)
  {
      static_assert(CurrentIndex + 1 <= Dimension, "Too much data in the vector constructor.");
      mData[CurrentIndex] = static_cast<Type>(arg1);
      initWithList<CurrentIndex + 1>(args...);
  }
  
  template <size_t Dimension, typename Type>
  template <size_t CurrentIndex>
  void VectorBase<Dimension, Type>::initWithList() const
  {
      static_assert(CurrentIndex == Dimension, "Not enough data in the vector constructor.");
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::Load(const Type *source)
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = source[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  void VectorBase<Dimension, Type>::Store(const Vector<Dimension, Type> &source, Type *destination)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          destination[i] = source.mData[i];
      }
  }
  
  // Implementation of basic arithmetic operations
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator+() const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = +mData[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator-() const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = -mData[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator+(
      const Vector<Dimension, Type> &other) const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = mData[i] + other.mData[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator-(
      const Vector<Dimension, Type> &other) const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = mData[i] - other.mData[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator*(
      const Vector<Dimension, Type> &other) const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = mData[i] * other.mData[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator/(
      const Vector<Dimension, Type> &other) const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = mData[i] / other.mData[i];
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator*(Type other) const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = mData[i] * other;
      }
      return result;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::operator/(Type other) const
  {
      Vector<Dimension, Type> result;
      for (size_t i = 0; i < Dimension; ++i)
      {
          result.mData[i] = mData[i] / other;
      }
      return result;
  }
  
  // Implementation of compound arithmetic operations
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> &VectorBase<Dimension, Type>::operator+=(
      const Vector<Dimension, Type> &other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] += other.mData[i];
      }
      return *static_cast<Vector<Dimension, Type> *>(this);
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> &VectorBase<Dimension, Type>::operator-=(
      const Vector<Dimension, Type> &other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] -= other.mData[i];
      }
      return *static_cast<Vector<Dimension, Type> *>(this);
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> &VectorBase<Dimension, Type>::operator*=(
      const Vector<Dimension, Type> &other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] *= other.mData[i];
      }
      return *static_cast<Vector<Dimension, Type> *>(this);
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> &VectorBase<Dimension, Type>::operator/=(
      const Vector<Dimension, Type> &other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] /= other.mData[i];
      }
      return *static_cast<Vector<Dimension, Type> *>(this);
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> &VectorBase<Dimension, Type>::operator*=(Type other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] *= other;
      }
      return *static_cast<Vector<Dimension, Type> *>(this);
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> &VectorBase<Dimension, Type>::operator/=(Type other)
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          mData[i] /= other;
      }
      return *static_cast<Vector<Dimension, Type> *>(this);
  }
  
  // Implementation of comparison operators
  template <size_t Dimension, typename Type>
  bool VectorBase<Dimension, Type>::operator==(const VectorBase<Dimension, Type> &other) const
  {
      for (size_t i = 0; i < Dimension; ++i)
      {
          if (mData[i] != other.mData[i])
          {
              return false;
          }
      }
      return true;
  }
  
  template <size_t Dimension, typename Type>
  bool VectorBase<Dimension, Type>::operator!=(const VectorBase<Dimension, Type> &other) const
  {
      return !(*this == other);
  }
  
  // Implementation of other arithmetic operations
  template <size_t Dimension, typename Type>
  Type VectorBase<Dimension, Type>::length() const
  {
      static_assert(std::is_floating_point<Type>::value,
                    "VectorN::length is only defined for floating point vectors");
      return std::sqrt(lengthSquared());
  }
  
  template <size_t Dimension, typename Type>
  Type VectorBase<Dimension, Type>::lengthSquared() const
  {
      return dot(*this);
  }
  
  template <size_t Dimension, typename Type>
  Type VectorBase<Dimension, Type>::dot(const VectorBase<Dimension, Type> &other) const
  {
      Type sum = Type();
      for (size_t i = 0; i < Dimension; ++i)
      {
          sum += mData[i] * other.mData[i];
      }
      return sum;
  }
  
  template <size_t Dimension, typename Type>
  std::ostream &operator<<(std::ostream &ostream, const VectorBase<Dimension, Type> &vector)
  {
      ostream << "[ ";
      for (size_t elementIdx = 0; elementIdx < Dimension; elementIdx++)
      {
          if (elementIdx > 0)
          {
              ostream << ", ";
          }
          ostream << vector.data()[elementIdx];
      }
      ostream << " ]";
      return ostream;
  }
  
  template <size_t Dimension, typename Type>
  Vector<Dimension, Type> VectorBase<Dimension, Type>::normalized() const
  {
      static_assert(std::is_floating_point<Type>::value,
                    "VectorN::normalized is only defined for floating point vectors");
      ASSERT(length() != Type());
      return *this / length();
  }
  
  template <typename Type>
  std::ostream &operator<<(std::ostream &ostream, const Vector<2, Type> &vector)
  {
      return ostream << static_cast<const VectorBase<2, Type> &>(vector);
  }
  
  template <typename Type>
  Vector<3, Type> Vector<3, Type>::cross(const Vector<3, Type> &other) const
  {
      return Vector<3, Type>(y() * other.z() - z() * other.y(), z() * other.x() - x() * other.z(),
                             x() * other.y() - y() * other.x());
  }
  
  template <typename Type>
  std::ostream &operator<<(std::ostream &ostream, const Vector<3, Type> &vector)
  {
      return ostream << static_cast<const VectorBase<3, Type> &>(vector);
  }
  
  template <typename Type>
  std::ostream &operator<<(std::ostream &ostream, const Vector<4, Type> &vector)
  {
      return ostream << static_cast<const VectorBase<4, Type> &>(vector);
  }
  
  }  // namespace angle
  
  #endif  // COMMON_VECTOR_UTILS_H_
  

Download