graphics_context.h

// © Joseph Cameron - All Rights Reserved

#ifndef GDK_GFX_CONTEXT_H
#define GDK_GFX_CONTEXT_H

#include <memory>

#include <gdk/entity.h>
#include <gdk/material.h>
#include <gdk/model.h>
#include <gdk/scene.h>
#include <gdk/screen_camera.h>
#include <gdk/shader_program.h>
#include <gdk/texture.h>
#include <gdk/texture_camera.h>
#include <gdk/vertex_data.h>

namespace gdk::graphics
{
    class entity_owner;

    class context
    {
    public:
        using context_ptr_type = std::shared_ptr<context>;
        using scene_ptr_type = std::shared_ptr<scene>;
        using entity_ptr_type = std::shared_ptr<entity>;
        using shader_program_ptr_type = std::shared_ptr<shader_program>;
        using model_ptr_type = std::shared_ptr<model>;
        using material_ptr_type = std::shared_ptr<material>;
        using texture_ptr_type = std::shared_ptr<texture>;
        using built_in_model_ptr_type = std::shared_ptr<model>;
        using built_in_shader_ptr_type = std::shared_ptr<shader_program>;
        using context_shared_ptr_type = std::shared_ptr<context>;
        using scene_shared_ptr_type = std::shared_ptr<scene>;
        using shader_program_shared_ptr_type = std::shared_ptr<shader_program>;
        using material_shared_ptr_type = std::shared_ptr<material>;
        using model_shared_ptr_type = std::shared_ptr<model>;
        using texture_shared_ptr_type = std::shared_ptr<texture>;

        enum class implementation
        {
            opengl_webgl1_gles2,
            null
        };

    //
        [[nodiscard]] static context_ptr_type make(
            const implementation &
        );

        [[nodiscard]] virtual scene_ptr_type make_scene() const = 0;

        [[nodiscard]] virtual std::shared_ptr<screen_camera> make_camera() const = 0;
        [[nodiscard]] virtual std::shared_ptr<screen_camera> make_camera(
            const camera &other 
        ) const = 0;
        
        [[nodiscard]] virtual std::shared_ptr<texture_camera> make_texture_camera() const = 0;
       
        [[nodiscard]] virtual entity_ptr_type make_entity(
            model_shared_ptr_type pModel, 
            material_shared_ptr_type pMaterial 
        ) const = 0;
        [[nodiscard]] virtual entity_ptr_type make_entity(
            const entity &other 
        ) const = 0;
       
        [[nodiscard]] virtual model_ptr_type make_model(
            const gdk::model::UsageHint &,
            const vertex_data &vertexDataView
        ) const = 0;

        [[nodiscard]] virtual model_ptr_type make_model() const = 0;

        [[nodiscard]] virtual material_ptr_type make_material(
            shader_program_shared_ptr_type pShader,
            material::render_mode aRenderMode = material::render_mode::opaque,
            material::FaceCullingMode aFaceCullingMode = material::FaceCullingMode::None) const = 0;

        [[nodiscard]] virtual shader_program_ptr_type make_shader(
            const std::string &aVertexStageSource, 
            const std::string &aFragmentStageSource
        ) const = 0;

        [[nodiscard]] virtual texture_ptr_type make_texture(
            const texture::image_data_2d_view &imageView
        ) const = 0;

        [[nodiscard]] virtual texture_ptr_type make_texture(
            const std::vector<std::underlying_type<std::byte>::type> &aRGBA32PNGData
        ) const = 0;

    //
        [[nodiscard]] virtual built_in_shader_ptr_type get_alpha_cutoff_shader() const = 0;

        [[nodiscard]] virtual built_in_shader_ptr_type get_pink_shader_of_death() const = 0;

        [[nodiscard]] virtual built_in_model_ptr_type get_cube_model() const = 0;

        [[nodiscard]] virtual built_in_model_ptr_type get_quad_model() const = 0;

        virtual ~context() = default;
    };
}

#endif