olcPGEX_Wireframe.h

Go to the documentation of this file.

/*
    olcPGEX_Wireframe.h
 
    +-------------------------------------------------------------+
    |         OneLoneCoder Pixel Game Engine Extension            |
    |                      Wireframe v1.0                         |
    +-------------------------------------------------------------+
 
    NOTE: UNDER ACTIVE DEVELOPMENT - THERE ARE BUGS/GLITCHES
 
    What is this?
    ~~~~~~~~~~~~~
    This extension provides drawing routines giving simple wireframe
    shapes and models constructed in a transform hierachy
 
    License (OLC-3)
    ~~~~~~~~~~~~~~~
 
    Copyright 2018 - 2022 OneLoneCoder.com
 
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:
 
    1. Redistributions or derivations of source code must retain the above
    copyright notice, this list of conditions and the following disclaimer.
 
    2. Redistributions or derivative works in binary form must reproduce
    the above copyright notice. This list of conditions and the following
    disclaimer must be reproduced in the documentation and/or other
    materials provided with the distribution.
 
    3. Neither the name of the copyright holder nor the names of its
    contributors may be used to endorse or promote products derived
    from this software without specific prior written permission.
 
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    Links
    ~~~~~
    YouTube:    https://www.youtube.com/javidx9
    Discord:    https://discord.gg/WhwHUMV
    Twitter:    https://www.twitter.com/javidx9
    Twitch:     https://www.twitch.tv/javidx9
    GitHub:     https://www.github.com/onelonecoder
    Homepage:   https://www.onelonecoder.com
 
    Author
    ~~~~~~
    David Barr, aka javidx9, ©OneLoneCoder 2019, 2020, 2021, 2022
 
    Revisions:
    1.00:   Initial Release
    
*/
 
#pragma once
#ifndef OLC_PGEX_WIREFRAME_H
#define OLC_PGEX_WIREFRAME_H
 
#include "olcPixelGameEngine.h"
 
namespace olc
{
#ifndef OLC_MAT3_DESC
#define OLC_MAT3_DESC
    template<typename T>
    struct mat3_generic
    {
        std::array<T, 9> m{ 0 };
        constexpr size_t idx(size_t r, size_t c) const { return r * 3 + c; }
        T& operator()(size_t row, size_t col) { return m[idx(row, col)]; }
        const T& operator()(size_t row, size_t col) const { return m[idx(row, col)]; }
        mat3_generic() { identity(); }
        mat3_generic(const mat3_generic& m) = default;
        mat3_generic& operator=(const mat3_generic& m) = default;
 
        void clear() { std::fill(m.begin(), m.end(), T(0)); }
        void identity() { clear(); (*this)(0, 0) = 1; (*this)(1, 1) = 1; (*this)(2, 2) = 1; }
 
        void translate(float x, float y) { identity();  auto& m = (*this); m(2, 0) = x; m(2, 1) = y; }
        void translate(const olc::v2d_generic<T>& v) { translate(v.x, v.y); }
        void scale(float x, float y) { identity(); auto& m = (*this); m(0, 0) = x; m(1, 1) = y; }
        void scale(const olc::v2d_generic<T>& v) { return scale(v.x, v.y); }
        void rotate(float a) { identity(); auto& m = (*this); m(0, 0) = cos(a); m(0, 1) = sin(a); m(1, 0) = -m(0, 1); m(1, 1) = m(0, 0); }
 
        olc::v2d_generic<T> operator * (const olc::v2d_generic<T>& v) const
        {
            auto& m = *this;
            olc::v2d_generic<T> vOut;
            vOut.x = m(0, 0) * v.x + m(1, 0) * v.y + m(2, 0) * T(1);
            vOut.y = m(0, 1) * v.x + m(1, 1) * v.y + m(2, 1) * T(1);
            T    z = m(0, 2) * v.x + m(1, 2) * v.y + m(2, 2) * T(1);
            return (vOut / z);
        }
 
        mat3_generic operator * (const mat3_generic& rhs) const
        {
            auto& m = *this;
            mat3_generic<T> out;
            for (size_t c = 0; c < 3; c++)
                for (size_t r = 0; r < 3; r++)
                    out(r, c) = m(r, 0) * rhs(0, c) + m(r, 1) * rhs(1, c) + m(r, 2) * rhs(2, c);
            return out;
        }
    };
 
    typedef mat3_generic<float> Matrix2D;
#endif
        
    namespace wire
    {
        typedef std::vector<olc::vf2d> Mesh;
        //Mesh NullMesh;
 
        class Model
        {
        public:
            static constexpr uint8_t DRAW_ORIGIN = 0x01;
            static constexpr uint8_t DRAW_NODES = 0x02;
            static constexpr uint8_t DRAW_MEASURES = 0x04;
        public:
            Model() = default;
 
        public:
            void Attach(Model* child, const olc::vf2d& position = { 0.0f, 0.0f }, const float angle = 0.0f);
            void SetRotation(const float angle);
            void SetPosition(const olc::vf2d& position);
            void UpdateInWorld(const Matrix2D& matParent);
            olc::vf2d LocalToWorld(const olc::vf2d& local);
            void SetMesh(const Mesh& mesh);
            const Mesh& GetWorldPoints() const;
            const std::vector<Model*>& GetChildren() const;
 
        protected:
            Mesh vLocalPoints;;
            Mesh vWorldPoints;
            olc::Matrix2D matLocalTranslation;
            olc::Matrix2D matLocalRotation;
            olc::Matrix2D matLocal;
            olc::Matrix2D matWorld;
 
        protected:
            std::vector<Model*> vChildren;
        };
 
 
 
        inline const Mesh MeshCircle(const float fRadius, const int nPoints = 100)
        {
            Mesh m;
            for (int i = 0; i < nPoints; i++)
            {
                float fTheta = (float(i) / float(nPoints)) * 2.0f * 3.14159f;
                m.push_back(olc::vf2d{ cos(fTheta), sin(fTheta) } *fRadius);
            }
            return m;
        }
 
        inline const Mesh MeshRectangle(const olc::vf2d& size, const olc::vf2d& offset = { 0.0f, 0.0f })
        {           
            return { -offset, {-offset.x + size.x, -offset.y}, -offset + size, {-offset.x, -offset.y + size.y} };           
        }
 
        inline const Mesh MeshGear(const int nTeeth, const float fOuterRadius, const float fInnerRadius)
        {
            Mesh m;
            for (int i = 0; i < nTeeth * 4; i++)
            {
                float fTheta = (float(i) / float(nTeeth * 4)) * 2.0f * 3.14159f;
                m.push_back(olc::vf2d{ cos(fTheta), sin(fTheta) }  * 2.0f * (float((i / 2) % 2) ? fOuterRadius : fInnerRadius));
            }
            return m;
        }
 
        template<typename T>
        void DrawModel(T& render, Model& m, const olc::Pixel col = olc::BLACK, const uint8_t flags = -1)
        {
            const auto& points = m.GetWorldPoints();
            for(size_t i = 0; i < points.size(); i++)
                render.DrawLine(points[i], points[(i+1)%points.size()], col);   
 
            // Draw Nodes
            if (flags & Model::DRAW_NODES)          
                for (size_t i = 0; i < points.size(); i++)                              
                    render.FillCircle(points[i], render.ScaleToWorld({ 3,3 }).x, olc::RED);
 
            if (flags & Model::DRAW_ORIGIN)
            {
                render.FillCircle(m.LocalToWorld({ 0,0 }), render.ScaleToWorld({ 3,3 }).x, olc::BLUE);
                render.DrawLine(
                    m.LocalToWorld({ 0,0 }),
                    m.LocalToWorld(render.ScaleToWorld({ 10, 0 })),
                    olc::BLUE);
            }
 
            // Draw Children
            for (auto& child : m.GetChildren())
                DrawModel<T>(render, *child, col, flags);
        }
 
        
    }
}
 
#ifdef OLC_PGEX_WIREFRAME
#undef OLC_PGEX_WIREFRAME
 
namespace olc
{
    namespace wire
    {
        void Model::SetMesh(const Mesh& mesh)
        {
            vLocalPoints = mesh;
            vWorldPoints.clear();
            vWorldPoints.resize(vLocalPoints.size());           
        }
 
        void Model::SetRotation(const float angle)
        {
            matLocalRotation.rotate(angle);
            matLocal = matLocalRotation * matLocalTranslation;
        }
 
        void Model::SetPosition(const olc::vf2d& position)
        {
            matLocalTranslation.translate(position);
            matLocal = matLocalRotation * matLocalTranslation;      
        }
 
        void Model::Attach(Model* child, const olc::vf2d& position, const float angle)
        {
            if (child != nullptr)
            {
                child->SetPosition(position);
                child->SetRotation(angle);
                vChildren.push_back(child);
            }
        }
 
        olc::vf2d Model::LocalToWorld(const olc::vf2d& local)
        {
            return matWorld * local;
        }
 
        const Mesh& Model::GetWorldPoints() const
        {
            return vWorldPoints;
        }
 
        const std::vector<Model*>& Model::GetChildren() const
        {
            return vChildren;
        }
 
        void Model::UpdateInWorld(const Matrix2D& matParent)
        {
            // Propagate matrix transform 
            matWorld = matLocal * matParent;
 
            // Transform vertices
            for (size_t i = 0; i < vLocalPoints.size(); i++)
            {
                vWorldPoints[i] = matWorld * vLocalPoints[i];
            }
    
            // Transform Children
            for (auto& child : vChildren)
                child->UpdateInWorld(matWorld);
        }
    }
}
 
#endif // OLC_PGEX_WIREFRAME
#endif // OLC_PGEX_WIREFRAME_H