graphic_context.h

/*
**  UICore
**  Copyright (c) 1997-2015 The UICore Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries UICore may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
**    Harry Storbacka
**    Kenneth Gangstoe
*/

#pragma once

#include "../../Core/Math/color.h"
#include "../Image/texture_format.h"
#include <memory>
#include "../../Core/Math/mat4.h"
#include "../../Core/Math/rect.h"
#include "../../Core/Signals/signal.h"
#include "primitives_array.h"
#include "frame_buffer.h"
#include "element_array_vector.h"
#include "shader_object.h"
#include "program_object.h"

namespace uicore
{
    class Size;
    class Texture;
    class FrameBuffer;
    class PixelBuffer;
    class PrimitivesArray;
    class Font;
    class FontMetrics;
    class GraphicContextImpl;
    class GraphicContext_Impl;
    class ProgramObject;
    class FontProvider_Freetype;
    class UniformBuffer;
    class StorageBuffer;
    class RasterizerStateDescription;
    class BlendStateDescription;
    class DepthStencilStateDescription;
    typedef std::shared_ptr<ProgramObject> ProgramObjectPtr;
    typedef std::shared_ptr<FrameBuffer> FrameBufferPtr;
    typedef std::shared_ptr<StorageBuffer> StorageBufferPtr;
    typedef std::shared_ptr<UniformBuffer> UniformBufferPtr;
    typedef std::shared_ptr<PrimitivesArray> PrimitivesArrayPtr;
    typedef std::shared_ptr<Texture> TexturePtr;
    typedef std::shared_ptr<PixelBuffer> PixelBufferPtr;

    enum CullMode
    {
        cull_front,
        cull_back,
        cull_front_and_back
    };

    enum FillMode
    {
        fill_point,
        fill_line,
        fill_polygon
    };

    enum FaceSide
    {
        face_clockwise,
        face_counter_clockwise
    };

    enum CompareFunction
    {
        compare_lequal,
        compare_gequal,
        compare_less,
        compare_greater,
        compare_equal,
        compare_notequal,
        compare_always,
        compare_never
    };

    enum StencilOp
    {
        stencil_keep,
        stencil_zero,
        stencil_replace,
        stencil_incr,
        stencil_decr,
        stencil_invert,
        stencil_incr_wrap,
        stencil_decr_wrap
    };

    enum DrawBuffer
    {
        buffer_none,
        buffer_front_left,
        buffer_front_right,
        buffer_back_left,
        buffer_back_right,
        buffer_front,
        buffer_back,
        buffer_left,
        buffer_right,
        buffer_front_and_back
    };

    enum LogicOp
    {
        logic_clear,
        logic_and,
        logic_and_reverse,
        logic_copy,
        logic_and_inverted,
        logic_noop,
        logic_xor,
        logic_or,
        logic_nor,
        logic_equiv,
        logic_invert,
        logic_or_reverse,
        logic_copy_inverted,
        logic_or_inverted,
        logic_nand,
        logic_set
    };

    enum BlendFunc
    {
        blend_zero,

        blend_one,

        blend_dest_color,

        blend_src_color,

        blend_one_minus_dest_color,

        blend_one_minus_src_color,

        blend_src_alpha,

        blend_one_minus_src_alpha,

        blend_dest_alpha,

        blend_one_minus_dest_alpha,

        blend_src_alpha_saturate,

        blend_constant_color,

        blend_one_minus_constant_color,

        blend_constant_alpha,

        blend_one_minus_constant_alpha
    };

    enum BlendEquation
    {
        equation_add,
        equation_subtract,
        equation_reverse_subtract,
        equation_min,
        equation_max
    };

    enum PointSpriteOrigin
    {
        origin_upper_left,
        origin_lower_left
    };

    enum PrimitivesType
    {
        type_points,
        type_line_strip,
        type_line_loop,
        type_lines,
        type_triangle_strip,
        type_triangle_fan,
        type_triangles
    };

    enum TextureImageYAxis
    {
        y_axis_bottom_up,  
        y_axis_top_down    
    };

    enum StandardProgram
    {
        program_color_only,
        program_single_texture,
        program_sprite,
        program_path
    };

    enum ShaderLanguage
    {
        shader_glsl,
        shader_hlsl,
        shader_fixed_function,
        num_shader_languages
    };

    class RasterizerState { };
    typedef std::shared_ptr<RasterizerState> RasterizerStatePtr;

    class BlendState { };
    typedef std::shared_ptr<BlendState> BlendStatePtr;

    class DepthStencilState { };
    typedef std::shared_ptr<DepthStencilState> DepthStencilStatePtr;

    class GraphicContext
    {
    public:
        virtual ClipZRange clip_z_range() const = 0;

        virtual TextureImageYAxis texture_image_y_axis() const = 0;

        virtual ShaderLanguage shader_language() const = 0;

        virtual int major_version() const = 0;

        virtual int minor_version() const = 0;

        virtual bool has_compute_shader_support() const = 0;

        virtual FrameBufferPtr write_frame_buffer() const = 0;

        virtual FrameBufferPtr read_frame_buffer() const = 0;

        virtual ProgramObjectPtr program_object() const = 0;

        int width() const { return size().width; }

        int height() const { return size().height; }

        virtual Size size() const = 0;

        virtual float pixel_ratio() const = 0;

        float dip_width() const { return width() / pixel_ratio(); }

        float dip_height() const { return height() / pixel_ratio(); }

        Sizef dip_size() const { return Sizef{ dip_width(), dip_height() }; }

        virtual Size max_texture_size() const = 0;

        virtual PixelBufferPtr pixeldata(const Rect& rect, TextureFormat texture_format = tf_rgba8, bool clamp = true) const = 0;

        PixelBufferPtr pixeldata(TextureFormat texture_format = tf_rgba8, bool clamp = true) { return pixeldata(Rect(Point(), size()), texture_format, clamp); }

        virtual bool is_frame_buffer_owner(const FrameBufferPtr &fb) = 0;

        virtual std::shared_ptr<RasterizerState> create_rasterizer_state(const RasterizerStateDescription &desc) = 0;

        virtual std::shared_ptr<BlendState> create_blend_state(const BlendStateDescription &desc) = 0;

        virtual std::shared_ptr<DepthStencilState> create_depth_stencil_state(const DepthStencilStateDescription &desc) = 0;

        void set_frame_buffer(const FrameBufferPtr &write_buffer) { set_frame_buffer(write_buffer, write_buffer); }
        virtual void set_frame_buffer(const FrameBufferPtr &write_buffer, const FrameBufferPtr &read_buffer) = 0;

        void reset_frame_buffer() { set_frame_buffer(nullptr); }

        virtual void set_uniform_buffer(int index, const UniformBufferPtr &buffer) = 0;

        void reset_uniform_buffer(int index) { set_uniform_buffer(index, nullptr); }

        virtual void set_storage_buffer(int index, const StorageBufferPtr &buffer) = 0;

        void reset_storage_buffer(int index) { set_storage_buffer(index, nullptr); }

        virtual void set_texture(int unit_index, const TexturePtr &texture) = 0;

        void set_textures(const std::vector<TexturePtr> &textures) { set_textures(0, textures); }
        void set_textures(int start_index, const std::vector<TexturePtr> &textures) { for (int i = 0; i < (int)textures.size(); i++) set_texture(start_index + i, textures[i]); }

        void reset_texture(int unit_index) { set_texture(unit_index, nullptr); }

        void reset_textures(int start_index, size_t count) { for (int i = 0; i < (int)count; i++) set_texture(start_index + i, nullptr); }

        virtual void set_image_texture(int unit_index, const TexturePtr &texture) = 0;

        void set_image_textures(const std::vector<TexturePtr> &textures) { set_image_textures(0, textures); }
        void set_image_textures(int start_index, const std::vector<TexturePtr> &textures) { for (int i = 0; i < (int)textures.size(); i++) set_image_texture(start_index + i, textures[i]); }

        void reset_image_texture(int unit_index) { set_image_texture(unit_index, nullptr); }

        void reset_image_textures(int start_index, size_t count) { for (int i = 0; i < (int)count; i++) set_image_texture(start_index + i, nullptr); }

        virtual void set_rasterizer_state(const RasterizerStatePtr &state) = 0;

        virtual void set_blend_state(const BlendStatePtr &state, const Colorf &blend_color = Colorf::white, unsigned int sample_mask = 0xffffffff) = 0;

        virtual void set_depth_stencil_state(const DepthStencilStatePtr &state, int stencil_ref = 0) = 0;

        void reset_rasterizer_state() { set_rasterizer_state(nullptr); }

        void reset_blend_state() { set_blend_state(nullptr); }

        void reset_depth_stencil_state() { set_depth_stencil_state(nullptr); }

        virtual void set_program_object(StandardProgram standard_program) = 0;

        virtual void set_program_object(const ProgramObjectPtr &program) = 0;

        void reset_program_object() { set_program_object(nullptr); }

        virtual bool is_primitives_array_owner(const PrimitivesArrayPtr &primitives_array) = 0;

        virtual void draw_primitives(PrimitivesType type, int num_vertices, const PrimitivesArrayPtr &array) = 0;

        virtual void set_primitives_array(const PrimitivesArrayPtr &array) = 0;

        void draw_primitives_array(PrimitivesType type, int num_vertices) { draw_primitives_array(type, 0, num_vertices); }

        virtual void draw_primitives_array(PrimitivesType type, int offset, int num_vertices) = 0;

        virtual void draw_primitives_array_instanced(PrimitivesType type, int offset, int num_vertices, int instance_count) = 0;

        virtual void set_primitives_elements(const ElementArrayBufferPtr &element_array) = 0;

        virtual void draw_primitives_elements(PrimitivesType type, int count, VertexAttributeDataType indices_type, size_t offset = 0) = 0;

        virtual void draw_primitives_elements_instanced(PrimitivesType type, int count, VertexAttributeDataType indices_type, size_t offset, int instance_count) = 0;

        void reset_primitives_elements() { set_primitives_elements(nullptr); }

        virtual void draw_primitives_elements(PrimitivesType type, int count, const ElementArrayBufferPtr &element_array, VertexAttributeDataType indices_type, size_t offset = 0) = 0;

        virtual void draw_primitives_elements_instanced(PrimitivesType type, int count, const ElementArrayBufferPtr &element_array, VertexAttributeDataType indices_type, size_t offset, int instance_count) = 0;

        void reset_primitives_array() { set_primitives_array(nullptr); }

        virtual void dispatch(int x = 1, int y = 1, int z = 1) = 0;

        virtual void clear(const Colorf &color = Colorf::black) = 0;

        virtual void clear_stencil(int value = 0) = 0;

        virtual void clear_depth(float value = 0) = 0;

        virtual void set_scissor(const Rect &rect, TextureImageYAxis y_axis) = 0;

        virtual void reset_scissor() = 0;

        virtual void set_viewport(const Rectf &viewport, TextureImageYAxis y_axis) = 0;

        virtual void set_viewport(int index, const Rectf &viewport, TextureImageYAxis y_axis) = 0;

        void set_depth_range(float n, float f) { set_depth_range(-1, n, f); }

        virtual void set_depth_range(int viewport, float n, float f) = 0;

        virtual void set_draw_buffer(DrawBuffer buffer) = 0;

        virtual void flush() = 0;
    };

    typedef std::shared_ptr<GraphicContext> GraphicContextPtr;
}