DebugDrawing.hpp

Go to the documentation of this file.

#pragma once
 
#include <glm/glm.hpp>
#include <vector>
#include "Geometry/Geometry3D.hpp"
 
namespace Video {
class Renderer;
class LowLevelRenderer;
class CommandBuffer;
class Buffer;
class Shader;
class ShaderProgram;
class GraphicsPipeline;
class VertexDescription;
class GeometryBinding;
 
class DebugDrawing {
  public:
    struct Point {
        glm::vec3 position;
 
        glm::vec3 color;
 
        float size;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Line {
        glm::vec3 startPosition;
 
        glm::vec3 endPosition;
 
        glm::vec3 color;
 
        float width;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Cuboid {
        glm::vec3 dimensions;
 
        glm::mat4 matrix;
 
        glm::vec3 color;
 
        float lineWidth;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Plane {
        glm::vec3 position;
 
        glm::vec3 normal;
 
        glm::vec2 size;
 
        glm::vec3 color;
 
        float lineWidth;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Circle {
        glm::vec3 position;
 
        glm::vec3 normal;
 
        float radius;
 
        glm::vec3 color;
 
        float lineWidth;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Sphere {
        glm::vec3 position;
 
        float radius;
 
        glm::vec3 color;
 
        float lineWidth;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Cylinder {
        float radius;
 
        float length;
 
        glm::mat4 matrix;
 
        glm::vec3 color;
 
        float lineWidth;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Cone {
        float radius;
 
        float height;
 
        glm::mat4 matrix;
 
        glm::vec3 color;
 
        float lineWidth;
 
        float duration;
 
        bool depthTesting;
    };
 
    struct Mesh {
        glm::mat4 matrix;
 
        glm::vec3 color;
 
        bool wireFrame;
 
        float duration;
 
        bool depthTesting;
 
        unsigned int indexCount = 0;
 
        GeometryBinding* geometryBinding = nullptr;
    };
 
 
    explicit DebugDrawing(Renderer* renderer);
 
    ~DebugDrawing();
 
 
    void StartDebugDrawing(CommandBuffer* commandBuffer, const glm::mat4& viewProjectionMatrix);
 
 
    void DrawPoint(const Point& point);
 
 
    void DrawLine(const Line& line);
 
 
    void DrawCuboid(const Cuboid& cuboid);
 
 
    void DrawPlane(const Plane& plane);
 
 
    void DrawCircle(const Circle& circle);
 
 
    void DrawSphere(const Sphere& sphere);
 
 
    void DrawCylinder(const Cylinder& cylinder);
 
 
    void DrawCone(const Cone& cone);
 
 
    void DrawMesh(const Mesh& mesh);
 
    void EndDebugDrawing();
 
  private:
    DebugDrawing(const DebugDrawing& other) = delete;
 
    void CreateVertexBuffer(const glm::vec3* positions, unsigned int positionCount, Buffer*& vertexBuffer, GeometryBinding*& geometryBinding);
    void BindGraphicsPipeline(GraphicsPipeline* graphicsPipeline);
    void BindGeometry(GeometryBinding* geometryBinding);
    void CreateCircle(glm::vec3*& positions, unsigned int& vertexCount, unsigned int detail);
    void CreateSphere(glm::vec3*& positions, unsigned int& vertexCount, unsigned int detail);
    void CreateCylinder(glm::vec3*& positions, unsigned int& vertexCount, unsigned int detail);
    void CreateCone(glm::vec3*& positions, unsigned int& vertexCount, unsigned int detail);
 
    Renderer* renderer;
    LowLevelRenderer* lowLevelRenderer;
    CommandBuffer* commandBuffer = nullptr;
    Shader* vertexShader;
    Shader* fragmentShader;
    ShaderProgram* shaderProgram;
    Shader* pointVertexShader;
    ShaderProgram* pointShaderProgram;
 
    GraphicsPipeline* pointGraphicsPipeline[2];
    GraphicsPipeline* lineGraphicsPipeline[2];
    GraphicsPipeline* lineTriangleGraphicsPipeline[2];
    GraphicsPipeline* fillTriangleGraphicsPipeline[2];
 
    // Shader resources.
    Buffer* matricesBuffer;
    struct PushConstantData {
        glm::mat4 modelMatrix;
        glm::vec4 colorSize;
    };
    struct PointPushConstantData {
        glm::vec4 position;
        glm::vec4 colorSize;
        glm::vec2 screenSize;
    };
 
    // Geometry.
    Buffer* pointVertexBuffer;
    GeometryBinding* pointGeometryBinding;
 
    Buffer* lineVertexBuffer;
    GeometryBinding* lineGeometryBinding;
 
    Buffer* cuboidVertexBuffer;
    GeometryBinding* cuboidGeometryBinding;
 
    Buffer* planeVertexBuffer;
    GeometryBinding* planeGeometryBinding;
 
    Buffer* sphereVertexBuffer;
    GeometryBinding* sphereGeometryBinding;
    unsigned int sphereVertexCount;
 
    Buffer* circleVertexBuffer;
    GeometryBinding* circleGeometryBinding;
    unsigned int circleVertexCount;
 
    Buffer* cylinderVertexBuffer;
    GeometryBinding* cylinderGeometryBinding;
    unsigned int cylinderVertexCount;
 
    Buffer* coneVertexBuffer;
    GeometryBinding* coneGeometryBinding;
    unsigned int coneVertexCount;
 
    VertexDescription* vertexDescription;
    VertexDescription* meshVertexDescription;
    GraphicsPipeline* boundGraphicsPipeline = nullptr;
    const GeometryBinding* boundGeometry = nullptr;
};
} // namespace Video