Primitive.hpp

#pragma once
#include "visuals/renderer/Object.hpp"
#ifdef StevEngine_RENDERER_GL
#include "renderer/RenderComponent.hpp"
#include "utilities/Vertex.hpp"
#include "visuals/Material.hpp"
 
#define CUBE_PRIMITIVE_TYPE "CubePrimitive"
#define UVSPHERE_PRIMITIVE_TYPE "UVSpherePrimitive"
#define ICOSPHERE_PRIMITIVE_TYPE "IcoSpherePrimitive"
#define CYLINDER_PRIMITIVE_TYPE "CylinderPrimitive"
#define CAPSULE_PRIMITIVE_TYPE "CapsulePrimitive"
 
#define RADIUS 0.5
 
namespace StevEngine {
    namespace Visuals {
        enum TextureType {
            REPEAT,  
            COVER   
        };

        const std::vector<Utilities::Vertex> CubeVertices(TextureType textureType);

        class CubePrimitive : public Renderer::RenderComponent {
            public:
                CubePrimitive(
                    Utilities::Vector3 position = Utilities::Vector3(),
                    Utilities::Quaternion rotation = Utilities::Quaternion(),
                    Utilities::Vector3 scale = Utilities::Vector3(1),
                    const Material& material = Material(),
                    TextureType textureType = REPEAT,
                    Renderer::RenderType renderType = Renderer::SOLID
                );

                CubePrimitive(Utilities::Stream& stream);

                std::string GetType() const { return CUBE_PRIMITIVE_TYPE; }

                Utilities::Stream Export(Utilities::StreamType type) const;
 
                const Visuals::TextureType textureType;  
        };

        const std::vector<Utilities::Vertex> UVSphereVertices(TextureType textureType, bool smooth, int detail = 30, float height = RADIUS);

        class UVSpherePrimitive : public Renderer::RenderComponent {
            public:
                UVSpherePrimitive(
                    Utilities::Vector3 position = Utilities::Vector3(),
                    Utilities::Quaternion rotation = Utilities::Quaternion(),
                    Utilities::Vector3 scale = Utilities::Vector3(1),
                    Material material = Material(),
                    bool smooth = true,
                    TextureType textureType = COVER,
                    Renderer::RenderType renderType = Renderer::SOLID
                );

                UVSpherePrimitive(Utilities::Stream& stream);

                std::string GetType() const { return UVSPHERE_PRIMITIVE_TYPE; }

                Utilities::Stream Export(Utilities::StreamType type) const;
 
                const Visuals::TextureType textureType;  
                const bool smooth;                       
        };

        const std::vector<Utilities::Vertex> IcosphereVertices(TextureType textureType, bool smooth, int detail = 3);

        class IcospherePrimitive : public Renderer::RenderComponent {
            public:
                IcospherePrimitive(
                    Utilities::Vector3 position = Utilities::Vector3(),
                    Utilities::Quaternion rotation = Utilities::Quaternion(),
                    Utilities::Vector3 scale = Utilities::Vector3(1),
                    Material material = Material(),
                    bool smooth = true,
                    TextureType textureType = COVER,
                    Renderer::RenderType renderType = Renderer::SOLID
                );

                IcospherePrimitive(Utilities::Stream& stream);

                std::string GetType() const { return ICOSPHERE_PRIMITIVE_TYPE; }

                Utilities::Stream Export(Utilities::StreamType type) const;
 
                const Visuals::TextureType textureType;  
                const bool smooth;                       
        };

        const std::vector<Utilities::Vertex> CylinderVertices(TextureType textureType, bool smooth, int detail = 30, double height = RADIUS);

        class CylinderPrimitive : public Renderer::RenderComponent {
            public:
                CylinderPrimitive(
                    Utilities::Vector3 position = Utilities::Vector3(),
                    Utilities::Quaternion rotation = Utilities::Quaternion(),
                    Utilities::Vector3 scale = Utilities::Vector3(1),
                    Material material = Material(),
                    bool smooth = true,
                    TextureType textureType = COVER,
                    Renderer::RenderType renderType = Renderer::SOLID
                );

                CylinderPrimitive(Utilities::Stream& stream);

                std::string GetType() const { return CYLINDER_PRIMITIVE_TYPE; }

                Utilities::Stream Export(Utilities::StreamType type) const;
 
                const Visuals::TextureType textureType;  
                const bool smooth;                       
        };

        const std::vector<Utilities::Vertex> CapsuleVertices(TextureType textureType, bool smooth, int detail = 30);

        class CapsulePrimitive : public Renderer::RenderComponent {
            public:
                CapsulePrimitive(
                    Utilities::Vector3 position = Utilities::Vector3(),
                    Utilities::Quaternion rotation = Utilities::Quaternion(),
                    Utilities::Vector3 scale = Utilities::Vector3(1),
                    Material material = Material(),
                    bool smooth = true,
                    TextureType textureType = COVER,
                    Renderer::RenderType renderType = Renderer::SOLID
                );

                CapsulePrimitive(Utilities::Stream& stream);

                std::string GetType() const { return CAPSULE_PRIMITIVE_TYPE; }

                Utilities::Stream Export(Utilities::StreamType type) const;
 
                const Visuals::TextureType textureType;  
                const bool smooth;                       
        };

        inline bool cube = CreateComponents::RegisterComponentType<CubePrimitive>(CUBE_PRIMITIVE_TYPE);
        inline bool sphere = CreateComponents::RegisterComponentType<UVSpherePrimitive>(UVSPHERE_PRIMITIVE_TYPE);
        inline bool icosphere = CreateComponents::RegisterComponentType<IcospherePrimitive>(ICOSPHERE_PRIMITIVE_TYPE);
        inline bool cylinder = CreateComponents::RegisterComponentType<CylinderPrimitive>(CYLINDER_PRIMITIVE_TYPE);
        inline bool capsule = CreateComponents::RegisterComponentType<CapsulePrimitive>(CAPSULE_PRIMITIVE_TYPE);
    }
}
#endif