polyline.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 https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include "mesh.h"
#include <mathutils.h>
#include <lineutils.h>
#include <unordered_map>
 
namespace nap
{
    // Forward Declares
    class Core;
    class RenderService;
 
    struct PolyLineProperties
    {
        EMemoryUsage    mUsage = EMemoryUsage::Static;          
        glm::vec4       mColor = { 1.0f, 1.0f, 1.0f,1.0f };         
    };
 
 
    // PolyLine
 
    class NAPAPI PolyLine : public IMesh
    {
        RTTI_ENABLE(IMesh)
    public:
        PolyLine(nap::Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual MeshInstance& getMeshInstance() override                        { return *mMeshInstance; }
 
        virtual const MeshInstance& getMeshInstance() const override            { return *mMeshInstance; }
 
        Vec3VertexAttribute& getPositionAttr();
        
        const Vec3VertexAttribute& getPositionAttr() const;
 
        Vec4VertexAttribute& getColorAttr();
 
        const Vec4VertexAttribute& getColorAttr() const;
        
        Vec3VertexAttribute& getNormalAttr();
 
        const Vec3VertexAttribute& getNormalAttr() const;
        
        Vec3VertexAttribute& getUvAttr();
 
        const Vec3VertexAttribute& getUvAttr() const;
 
        template<typename T>
        void getValue(const VertexAttribute<T>& attr, float location, T& outValue) const;
 
        template<typename T>
        void getValue(const std::map<float, int>& distanceMap, const VertexAttribute<T>& attr, float location, T& outValue) const;
 
        void getNormal(const std::map<float, int>& distanceMap, const Vec3VertexAttribute& attr, float location, glm::vec3& outValue) const;
 
        float getDistances(std::map<float, int>& outDistances) const;
 
        virtual bool isClosed() const = 0;
 
        // Properties associated with a line
        PolyLineProperties mLineProperties;
 
    protected:
        std::unique_ptr<MeshInstance> mMeshInstance;
        RenderService* mRenderService = nullptr;
 
        static void createVertexAttributes(MeshInstance& instance);
    };
 
 
    // Line
 
    class NAPAPI Line : public PolyLine
    {
        RTTI_ENABLE(PolyLine)
    public:
        Line(nap::Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool isClosed() const override                      { return mClosed; }
 
        glm::vec3 mStart    = { -0.5f, 0.0f, 0.0f };                
        glm::vec3 mEnd      = { 0.5f, 0.0f, 0.0f };                 
        bool mClosed        = false;                                
        int mVertexCount    = 2;                                    
 
    };
 
 
    // Rectangle
 
    class NAPAPI Rectangle : public PolyLine
    {
        RTTI_ENABLE(PolyLine)
    public:
        Rectangle(nap::Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool isClosed() const override                      { return true; }
 
        glm::vec2 mDimensions = { 1.0f, 1.0f };                     
    };
 
 
    // Circle
 
    class NAPAPI Circle : public PolyLine
    {
        RTTI_ENABLE(PolyLine)
    public:
        Circle(nap::Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool isClosed() const override                  { return true; }
 
        float mRadius = 1.0f;                                   
        int mSegments = 100;                                    
    };
 
 
    // Hexagon
    
    class NAPAPI Hexagon : public PolyLine
    {
        RTTI_ENABLE(PolyLine)
    public:
        Hexagon(nap::Core& core);
        float mRadius = 1.0f;                                   
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool isClosed() const override                  { return true; }
    };
 
 
    // TriangleLine
    
    class NAPAPI TriangleLine : public PolyLine
    {
        RTTI_ENABLE(PolyLine)
    public:
        TriangleLine(nap::Core& core);
        float mRadius = 1.0f;                                   
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool isClosed() const override                  { return true; }
    };
 
 
    // Template definitions
    
    template<typename T>
    void nap::PolyLine::getValue(const VertexAttribute<T>& attr, float location, T& outValue) const
    {
        return math::getValueAlongLine(attr.getData(), location, isClosed(), outValue);
    }
 
    template<typename T>
    void nap::PolyLine::getValue(const std::map<float, int>& distanceMap, const VertexAttribute<T>& attr, float location, T& outValue) const
    {
        return math::getValueAlongLine(distanceMap, attr.getData(), location, outValue);
    }
}