TriangleClipper.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Math/Geometry.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine {
 
    template<typename T> class TriangleClipper {
    protected:
        struct ClipVert {
            ClipVert() {}
 
            TVector3<T> point = TVector3<T>(0);
            TVector2<T> uv = TVector2<T>(0);
            T distance = 0.0f;
            UInt32 occurs = 0;
            bool visible = true;
        };
 
        struct ClipEdge {
            ClipEdge() {}
 
            UInt32 verts[2];
            Vector<UInt32> faces;
            bool visible = true;
        };
 
        struct ClipFace {
            ClipFace() {}
 
            Vector<UInt32> edges;
            bool visible = true;
            TVector3<T> normal = TVector3<T>(0);
        };
 
        struct ClipMesh {
            ClipMesh() {}
 
            Vector<ClipVert> verts;
            Vector<ClipEdge> edges;
            Vector<ClipFace> faces;
        };
 
    protected:
        void addEdgesAndFaces();
 
        Int32 clipByPlane(const TPlane<T>& plane);
 
        Int32 processVertices(const TPlane<T>& plane);
 
        void processEdges();
 
        void processFaces();
 
        void getOrderedFaces(Vector<Vector<UInt32>>& sortedFaces);
 
        void getOrderedVertices(const ClipFace& face, Vector<UInt32>& vertices);
 
        TVector3<T> getNormal(Vector<UInt32>& sortedVertices, UInt32 numVertices);
 
        bool getOpenPolyline(ClipFace& face, UInt32& start, UInt32& end);
 
        ClipMesh mesh;
    };
 
    template<typename T> class TriangleClipper2D : public TriangleClipper<T> {
    public:
        void clip(UInt8* vertices, UInt8* uvs, UInt32 numTris, UInt32 vertexStride, const Vector<TPlane<T>>& clipPlanes,
            const std::function<void(TVector2<T>*, TVector2<T>*, UInt32)>& writeCallback);
 
    private:
        void convertToMesh(const std::function<void(TVector2<T>*, TVector2<T>*, UInt32)>& writeCallback);
 
        static const int BUFFER_SIZE = 64 * 3; // Must be a multiple of three
        TVector2<T> vertexBuffer[BUFFER_SIZE];
        TVector2<T> uvBuffer[BUFFER_SIZE];
    };
 
    template<typename T> class TriangleClipper3D : public TriangleClipper<T> {
    public:
        void clip(UInt8* vertices, UInt8* uvs, UInt32 numTris, UInt32 vertexStride, const Vector<TPlane<T>>& clipPlanes,
            const std::function<void(TVector3<T>*, TVector2<T>*, UInt32)>& writeCallback);
 
    private:
        void convertToMesh(const std::function<void(TVector3<T>*, TVector2<T>*, UInt32)>& writeCallback);
 
        static const int BUFFER_SIZE = 64 * 3; // Must be a multiple of three
        TVector3<T> vertexBuffer[BUFFER_SIZE];
        TVector2<T> uvBuffer[BUFFER_SIZE];
    };
 
    extern template class TriangleClipper<float>;
    extern template class TriangleClipper2D<float>;
    extern template class TriangleClipper3D<float>;
 
    extern template class TriangleClipper<double>;
    extern template class TriangleClipper2D<double>;
    extern template class TriangleClipper3D<double>;
 
} // namespace CeresEngine