Types.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_TYPES_H
#define MATERIALX_TYPES_H

 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Util.h>
 
#include <array>
#include <cmath>
 
MATERIALX_NAMESPACE_BEGIN
 
extern MX_CORE_API const string DEFAULT_TYPE_STRING;
extern MX_CORE_API const string FILENAME_TYPE_STRING;
extern MX_CORE_API const string GEOMNAME_TYPE_STRING;
extern MX_CORE_API const string STRING_TYPE_STRING;
extern MX_CORE_API const string BSDF_TYPE_STRING;
extern MX_CORE_API const string EDF_TYPE_STRING;
extern MX_CORE_API const string VDF_TYPE_STRING;
extern MX_CORE_API const string SURFACE_SHADER_TYPE_STRING;
extern MX_CORE_API const string DISPLACEMENT_SHADER_TYPE_STRING;
extern MX_CORE_API const string VOLUME_SHADER_TYPE_STRING;
extern MX_CORE_API const string LIGHT_SHADER_TYPE_STRING;
extern MX_CORE_API const string MATERIAL_TYPE_STRING;
extern MX_CORE_API const string SURFACE_MATERIAL_NODE_STRING;
extern MX_CORE_API const string VOLUME_MATERIAL_NODE_STRING;
extern MX_CORE_API const string MULTI_OUTPUT_TYPE_STRING;
extern MX_CORE_API const string NONE_TYPE_STRING;
extern MX_CORE_API const string VALUE_STRING_TRUE;
extern MX_CORE_API const string VALUE_STRING_FALSE;
extern MX_CORE_API const string NAME_PREFIX_SEPARATOR;
extern MX_CORE_API const string NAME_PATH_SEPARATOR;
extern MX_CORE_API const string ARRAY_VALID_SEPARATORS;
extern MX_CORE_API const string ARRAY_PREFERRED_SEPARATOR;

class VectorBase { };

class Uninit { };

template <class V, class S, size_t N> class VectorN : public VectorBase
{
  public:
    using Iterator = typename std::array<S, N>::iterator;
    using ConstIterator = typename std::array<S, N>::const_iterator;
 
  public:
    VectorN() : _arr{} { }
    explicit VectorN(Uninit) { }
    explicit VectorN(S s) { _arr.fill(s); }
    explicit VectorN(const std::array<S, N>& arr) : _arr(arr) { }
    explicit VectorN(const vector<S>& vec) { std::copy(vec.begin(), vec.end(), _arr.begin()); }
    explicit VectorN(const S* begin, const S* end) { std::copy(begin, end, _arr.begin()); }


    bool operator==(const V& rhs) const { return _arr == rhs._arr; }

    bool operator!=(const V& rhs) const { return _arr != rhs._arr; }

    bool operator<(const V& rhs) const
    {
        return _arr < rhs._arr;
    }


    S& operator[](size_t i) { return _arr.at(i); }

    const S& operator[](size_t i) const { return _arr.at(i); }


    V operator+(const V& rhs) const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = _arr[i] + rhs[i];
        return res;
    }

    VectorN& operator+=(const V& rhs)
    {
        for (size_t i = 0; i < N; i++)
            _arr[i] += rhs[i];
        return *this;
    }

    V operator-(const V& rhs) const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = _arr[i] - rhs[i];
        return res;
    }

    VectorN& operator-=(const V& rhs)
    {
        for (size_t i = 0; i < N; i++)
            _arr[i] -= rhs[i];
        return *this;
    }

    V operator*(const V& rhs) const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = _arr[i] * rhs[i];
        return res;
    }

    VectorN& operator*=(const V& rhs)
    {
        for (size_t i = 0; i < N; i++)
            _arr[i] *= rhs[i];
        return *this;
    }

    V operator/(const V& rhs) const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = _arr[i] / rhs[i];
        return res;
    }

    VectorN& operator/=(const V& rhs)
    {
        for (size_t i = 0; i < N; i++)
            _arr[i] /= rhs[i];
        return *this;
    }

    V operator*(S s) const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = _arr[i] * s;
        return res;
    }

    VectorN& operator*=(S s)
    {
        for (size_t i = 0; i < N; i++)
            _arr[i] *= s;
        return *this;
    }

    V operator/(S s) const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = _arr[i] / s;
        return res;
    }

    VectorN& operator/=(S s)
    {
        for (size_t i = 0; i < N; i++)
            _arr[i] /= s;
        return *this;
    }

    V operator-() const
    {
        V res(Uninit{});
        for (size_t i = 0; i < N; i++)
            res[i] = -_arr[i];
        return res;
    }


    S getMagnitude() const
    {
        S res{};
        for (size_t i = 0; i < N; i++)
            res += _arr[i] * _arr[i];
        return std::sqrt(res);
    }

    V getNormalized() const
    {
        return *this / getMagnitude();
    }

    S dot(const V& rhs) const
    {
        S res{};
        for (size_t i = 0; i < N; i++)
            res += _arr[i] * rhs[i];
        return res;
    }

 
    Iterator begin() { return _arr.begin(); }
    ConstIterator begin() const { return _arr.begin(); }
 
    Iterator end() { return _arr.end(); }
    ConstIterator end() const { return _arr.end(); }


    S* data() { return _arr.data(); }

    const S* data() const { return _arr.data(); }

    class Hash
    {
      public:
        size_t operator()(const V& v) const noexcept
        {
            size_t h = 0;
            for (size_t i = 0; i < N; i++)
                hashCombine(h, v[i]);
            return h;
        }
    };


    static constexpr size_t numElements() { return N; }

 
  protected:
    std::array<S, N> _arr;
};

class MX_CORE_API Vector2 : public VectorN<Vector2, float, 2>
{
  public:
    using VectorN<Vector2, float, 2>::VectorN;
    Vector2() = default;
    Vector2(float x, float y) :
        VectorN(Uninit{})
    {
        _arr = { x, y };
    }

    float cross(const Vector2& rhs) const
    {
        return _arr[0] * rhs[1] - _arr[1] * rhs[0];
    }
};

class MX_CORE_API Vector3 : public VectorN<Vector3, float, 3>
{
  public:
    using VectorN<Vector3, float, 3>::VectorN;
    Vector3() = default;
    Vector3(float x, float y, float z) :
        VectorN(Uninit{})
    {
        _arr = { x, y, z };
    }

    Vector3 cross(const Vector3& rhs) const
    {
        return Vector3(_arr[1] * rhs[2] - _arr[2] * rhs[1],
                       _arr[2] * rhs[0] - _arr[0] * rhs[2],
                       _arr[0] * rhs[1] - _arr[1] * rhs[0]);
    }
};

class MX_CORE_API Vector4 : public VectorN<Vector4, float, 4>
{
  public:
    using VectorN<Vector4, float, 4>::VectorN;
    Vector4() = default;
    Vector4(float x, float y, float z, float w) :
        VectorN(Uninit{})
    {
        _arr = { x, y, z, w };
    }
};

class MX_CORE_API Color3 : public VectorN<Color3, float, 3>
{
  public:
    using VectorN<Color3, float, 3>::VectorN;
    Color3() = default;
    Color3(float r, float g, float b) :
        VectorN(Uninit{})
    {
        _arr = { r, g, b };
    }

    Color3 linearToSrgb() const;

    Color3 srgbToLinear() const;
};

class MX_CORE_API Color4 : public VectorN<Color4, float, 4>
{
  public:
    using VectorN<Color4, float, 4>::VectorN;
    Color4() = default;
    Color4(float r, float g, float b, float a) :
        VectorN(Uninit{})
    {
        _arr = { r, g, b, a };
    }
};

class MatrixBase { };

template <class M, class S, size_t N> class MatrixN : public MatrixBase
{
  public:
    using RowArray = typename std::array<S, N>;
    using Iterator = typename std::array<RowArray, N>::iterator;
    using ConstIterator = typename std::array<RowArray, N>::const_iterator;
 
  public:
    MatrixN() : _arr{} { }
    explicit MatrixN(Uninit) { }
    explicit MatrixN(S s) { std::fill_n(&_arr[0][0], N * N, s); }
    explicit MatrixN(const S* begin, const S* end) { std::copy(begin, end, &_arr[0][0]); }


    bool operator==(const M& rhs) const { return _arr == rhs._arr; }

    bool operator!=(const M& rhs) const { return _arr != rhs._arr; }

    bool isEquivalent(const M& rhs, S tolerance) const
    {
        for (size_t i = 0; i < N; i++)
        {
            for (size_t j = 0; j < N; j++)
            {
                if (std::abs(_arr[i][j] - rhs[i][j]) > tolerance)
                {
                    return false;
                }
            }
        }
        return true;
    }


    RowArray& operator[](size_t i) { return _arr.at(i); }

    const RowArray& operator[](size_t i) const { return _arr.at(i); }


    M operator+(const M& rhs) const
    {
        M res(Uninit{});
        for (size_t i = 0; i < N; i++)
            for (size_t j = 0; j < N; j++)
                res[i][j] = _arr[i][j] + rhs[i][j];
        return res;
    }

    MatrixN& operator+=(const M& rhs)
    {
        *this = *this + rhs;
        return *this;
    }

    M operator-(const M& rhs) const
    {
        M res(Uninit{});
        for (size_t i = 0; i < N; i++)
            for (size_t j = 0; j < N; j++)
                res[i][j] = _arr[i][j] - rhs[i][j];
        return res;
    }

    MatrixN& operator-=(const M& rhs)
    {
        *this = *this - rhs;
        return *this;
    }

    M operator*(S s) const
    {
        M res(Uninit{});
        for (size_t i = 0; i < N; i++)
            for (size_t j = 0; j < N; j++)
                res[i][j] = _arr[i][j] * s;
        return res;
    }

    MatrixN& operator*=(S s)
    {
        *this = *this * s;
        return *this;
    }

    M operator/(S s) const
    {
        M res(Uninit{});
        for (size_t i = 0; i < N; i++)
            for (size_t j = 0; j < N; j++)
                res[i][j] = _arr[i][j] / s;
        return res;
    }

    MatrixN& operator/=(S s)
    {
        *this = *this / s;
        return *this;
    }


    M operator*(const M& rhs) const
    {
        M res;
        for (size_t i = 0; i < N; i++)
            for (size_t j = 0; j < N; j++)
                for (size_t k = 0; k < N; k++)
                    res[i][j] += _arr[i][k] * rhs[k][j];
        return res;
    }

    MatrixN& operator*=(const M& rhs)
    {
        *this = *this * rhs;
        return *this;
    }

    M operator/(const M& rhs) const
    {
        return *this * rhs.getInverse();
    }

    MatrixN& operator/=(const M& rhs)
    {
        *this *= rhs.getInverse();
        return *this;
    }

 
    Iterator begin() { return _arr.begin(); }
    ConstIterator begin() const { return _arr.begin(); }
 
    Iterator end() { return _arr.end(); }
    ConstIterator end() const { return _arr.end(); }


    S* data() { return _arr.front().data(); }

    const S* data() const { return _arr.front().data(); }


    static constexpr size_t numRows() { return N; }

    static constexpr size_t numColumns() { return N; }

 
  protected:
    std::array<RowArray, N> _arr;
};

class MX_CORE_API Matrix33 : public MatrixN<Matrix33, float, 3>
{
  public:
    using MatrixN<Matrix33, float, 3>::MatrixN;
    Matrix33() = default;
    Matrix33(float m00, float m01, float m02,
             float m10, float m11, float m12,
             float m20, float m21, float m22) :
        MatrixN(Uninit{})
    {
        _arr = { RowArray{ m00, m01, m02 },
                 RowArray{ m10, m11, m12 },
                 RowArray{ m20, m21, m22 } };
    }


    Matrix33 getTranspose() const;

    float getDeterminant() const;

    Matrix33 getAdjugate() const;

    Matrix33 getInverse() const
    {
        return getAdjugate() / getDeterminant();
    }


    Vector3 multiply(const Vector3& v) const;

    Vector2 transformPoint(const Vector2& v) const;

    Vector2 transformVector(const Vector2& v) const;

    Vector3 transformNormal(const Vector3& v) const;

    static Matrix33 createTranslation(const Vector2& v);

    static Matrix33 createScale(const Vector2& v);

    static Matrix33 createRotation(float angle);

 
  public:
    static const Matrix33 IDENTITY;
};

class MX_CORE_API Matrix44 : public MatrixN<Matrix44, float, 4>
{
  public:
    using MatrixN<Matrix44, float, 4>::MatrixN;
    Matrix44() = default;
    Matrix44(float m00, float m01, float m02, float m03,
             float m10, float m11, float m12, float m13,
             float m20, float m21, float m22, float m23,
             float m30, float m31, float m32, float m33) :
        MatrixN(Uninit{})
    {
        _arr = { RowArray{ m00, m01, m02, m03 },
                 RowArray{ m10, m11, m12, m13 },
                 RowArray{ m20, m21, m22, m23 },
                 RowArray{ m30, m31, m32, m33 } };
    }


    Matrix44 getTranspose() const;

    float getDeterminant() const;

    Matrix44 getAdjugate() const;

    Matrix44 getInverse() const
    {
        return getAdjugate() / getDeterminant();
    }


    Vector4 multiply(const Vector4& v) const;

    Vector3 transformPoint(const Vector3& v) const;

    Vector3 transformVector(const Vector3& v) const;

    Vector3 transformNormal(const Vector3& v) const;

    static Matrix44 createTranslation(const Vector3& v);

    static Matrix44 createScale(const Vector3& v);

    static Matrix44 createRotationX(float angle);

    static Matrix44 createRotationY(float angle);

    static Matrix44 createRotationZ(float angle);

 
  public:
    static const Matrix44 IDENTITY;
};
 
MATERIALX_NAMESPACE_END
 
#endif