context.h

// © Joseph Cameron - MIT License
 
#ifndef GDK_GRAPHICS_CONTEXT_H
#define GDK_GRAPHICS_CONTEXT_H
 
#include <gdk/graphics/entity.h>
#include <gdk/graphics/limits.h>
#include <gdk/graphics/types.h>
 
#include <cstddef>
#include <gdk/graphics/material.h>
#include <gdk/graphics/model.h>
#include <gdk/graphics/scene.h>
#include <gdk/graphics/screen_camera.h>
#include <gdk/graphics/shader_program.h>
#include <gdk/graphics/texture.h>
#include <gdk/graphics/texture_camera.h>
 
#include <memory>
 
namespace gdk::graphics {
        class context {
        public:
        //
            [[nodiscard]] virtual scene_ptr_type make_scene() = 0;

            [[nodiscard]] virtual screen_camera_ptr_type make_camera() = 0;
            
            [[nodiscard]] virtual texture_camera_ptr_type make_texture_camera() = 0;

            [[nodiscard]] virtual texture_camera_ptr_type make_texture_camera(const intvector2_type &aSize) = 0;
           
            [[nodiscard]] virtual entity_ptr_type make_entity(
                const const_model_ptr_type pModel, 
                const const_material_ptr_type pMaterial 
            ) = 0;
            
            [[nodiscard]] virtual model_ptr_type make_model(
                const gdk::graphics::model::usage_hint,
                const model_data &vertexData
            ) = 0;
            [[nodiscard]] virtual model_ptr_type make_model() = 0;

            [[nodiscard]] virtual material_ptr_type make_material(
                const const_shader_ptr_type pShader,
                const material::render_mode aRenderMode,
                const material::face_culling_mode aFaceCullingMode
            ) = 0;

            [[nodiscard]] material_ptr_type make_material(const const_shader_ptr_type pShader,
                const material::render_mode aRenderMode) {
                return make_material(pShader, aRenderMode, material::face_culling_mode::none);
            }

            [[nodiscard]] material_ptr_type make_material(const const_shader_ptr_type pShader) {
                return make_material(pShader, material::render_mode::opaque, material::face_culling_mode::none);
            }

            [[nodiscard]] virtual material_ptr_type make_material(
                const const_material_ptr_type &aPrototype) = 0;

            [[nodiscard]] virtual texture_ptr_type make_texture(
                const texture_data::view &aTextureDataView,
                const texture::wrap_mode aWrapModeU,
                const texture::wrap_mode aWrapModeV,
                const texture::filter_mode aFilterMode
            ) = 0;

            [[nodiscard]] texture_ptr_type make_texture(const texture_data::view &aTextureDataView,
                const texture::wrap_mode aWrapModeU, const texture::wrap_mode aWrapModeV) {
                return make_texture(aTextureDataView, aWrapModeU, aWrapModeV, texture::filter_mode::sharp);
            }

            [[nodiscard]] texture_ptr_type make_texture(const texture_data::view &aTextureDataView) {
                return make_texture(aTextureDataView, texture::wrap_mode::repeat, texture::wrap_mode::repeat,
                    texture::filter_mode::sharp);
            }

            [[nodiscard]] virtual texture_ptr_type make_texture() = 0;

        //
            [[nodiscard]] virtual model_ptr_type make_cube_model() const = 0;
 
            [[nodiscard]] virtual model_ptr_type make_sphere_model() const = 0;

            [[nodiscard]] virtual shader_ptr_type make_alpha_cutoff_shader() const = 0;

            [[nodiscard]] virtual shader_ptr_type make_alpha_blend_shader() const = 0;

            [[nodiscard]] virtual graphics::limits limits() const = 0;

            virtual ~context() = default;
    };
}
 
#endif