pointTypes.h

/*
This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#pragma once
 
#include "./defines.h"
#include <Eigen/Core>
 
namespace Ponca
{
    // [PointPositionNormal]
    template <typename _Scalar, int _Dim>
    class PointPositionNormal
    {
    public:
        enum
        {
            Dim = _Dim
        };
        using Scalar     = _Scalar;
        using VectorType = Eigen::Matrix<Scalar, Dim, 1>;
        using MatrixType = Eigen::Matrix<Scalar, Dim, Dim>;
 
        PONCA_MULTIARCH inline PointPositionNormal(const VectorType& pos    = VectorType::Zero(),
                                                   const VectorType& normal = VectorType::Zero())
            : m_pos(pos), m_normal(normal)
        {
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline const VectorType& pos() const { return m_pos; }
        PONCA_MULTIARCH [[nodiscard]] inline const VectorType& normal() const { return m_normal; }
        PONCA_MULTIARCH [[nodiscard]] inline VectorType& pos() { return m_pos; }
        PONCA_MULTIARCH [[nodiscard]] inline VectorType& normal() { return m_normal; }
 
    private:
        VectorType m_pos, m_normal;
    };
    // [PointPositionNormal]
 
    // [PointPosition]
    template <typename _Scalar, int _Dim>
    class PointPosition
    {
    public:
        enum
        {
            Dim = _Dim
        };
        using Scalar     = _Scalar;
        using VectorType = Eigen::Matrix<Scalar, Dim, 1>;
        using MatrixType = Eigen::Matrix<Scalar, Dim, Dim>;
 
        PONCA_MULTIARCH inline PointPosition(const VectorType& pos = VectorType::Zero()) : m_pos(pos) {}
 
        PONCA_MULTIARCH [[nodiscard]] inline const VectorType& pos() const { return m_pos; }
        PONCA_MULTIARCH [[nodiscard]] inline VectorType& pos() { return m_pos; }
 
    private:
        VectorType m_pos;
    };
    // [PointPosition]
 
    // [PointPositionNormalBinding]
    template <typename _Scalar, int _Dim>
    class PointPositionNormalBinding
    {
    public:
        enum
        {
            Dim = _Dim
        };
        using Scalar     = _Scalar;
        using VectorType = Eigen::Matrix<Scalar, Dim, 1>;
        using MatrixType = Eigen::Matrix<Scalar, Dim, Dim>;
 
        PONCA_MULTIARCH inline PointPositionNormalBinding(const Scalar* _interlacedArray, const int _pId)
            : m_pos(Eigen::Map<const VectorType>(_interlacedArray + Dim * 2 * _pId)),
              m_normal(Eigen::Map<const VectorType>(_interlacedArray + Dim * 2 * _pId + Dim))
        {
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline const Eigen::Map<const VectorType>& pos() const { return m_pos; }
        PONCA_MULTIARCH [[nodiscard]] inline const Eigen::Map<const VectorType>& normal() const { return m_normal; }
 
    private:
        const Eigen::Map<const VectorType> m_pos, m_normal;
    };
    // [PointPositionNormalBinding]
 
    // [PointPositionNormalLazyBinding]
    template <typename _Scalar, int _Dim>
    class PointPositionNormalLazyBinding
    {
    public:
        enum
        {
            Dim = _Dim
        };
        using Scalar     = _Scalar;
        using VectorType = Eigen::Matrix<Scalar, Dim, 1>;
        using MatrixType = Eigen::Matrix<Scalar, Dim, Dim>;
 
        PONCA_MULTIARCH inline PointPositionNormalLazyBinding(Scalar* _interlacedArray, const int _pId)
            : m_interlacedArray(_interlacedArray), m_id(_pId)
        {
        }
 
        PONCA_MULTIARCH inline void bind(Scalar* _interlacedArray) { m_interlacedArray = _interlacedArray; }
 
        PONCA_MULTIARCH [[nodiscard]] inline Eigen::Map<const VectorType> pos() const
        {
            return Eigen::Map<const VectorType>(m_interlacedArray + Dim * 2 * m_id);
        }
        PONCA_MULTIARCH [[nodiscard]] inline Eigen::Map<const VectorType> normal() const
        {
            return Eigen::Map<const VectorType>(m_interlacedArray + Dim * 2 * m_id + Dim);
        }
 
    private:
        Scalar* m_interlacedArray;
        const int m_id;
    };
    // [PointPositionNormalLazyBinding]
} // namespace Ponca