context.h

#pragma once
 
// make sure this is the first thing the compiler sees, while preventing warnings if
// it happened to already be defined by something else including this header
#ifndef _USE_MATH_DEFINES
    #define _USE_MATH_DEFINES 1
#endif
#include <cgv/defines/deprecated.h>
#include <cgv/data/data_view.h>
#include <cgv/media/font/font.h>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/media/illum/phong_material.h>
#include <cgv/media/illum/textured_surface_material.h>
#include <cgv/media/illum/light_source.h>
#include <cgv/signal/callback_stream.h>
#include <cgv/math/vec.h>
#include <cgv/math/inv.h>
#include <stack>
#include <vector>
#include <string>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace render {
 
class CGV_API drawable;
class CGV_API textured_material;
 
enum GPUVendorID {
    GPU_VENDOR_UNKNOWN,
    GPU_VENDOR_AMD,
    GPU_VENDOR_INTEL,
    GPU_VENDOR_NVIDIA
};
 
struct device_capabilities {
    int max_geometry_shader_output_vertex_count = -1;   
    int max_compute_shared_memory_size = -1;            
    int max_compute_work_group_invocations = -1;        
    ivec3 max_compute_work_group_count = -1;            
    ivec3 max_compute_work_group_size = -1;             
};
 
enum ElementType {
    ET_VALUE,
    ET_VECTOR,
    ET_MATRIX
};
 
struct type_descriptor
{
    cgv::type::info::TypeId coordinate_type : 8;
    ElementType element_type : 4;
    unsigned nr_rows : 4;
    unsigned nr_columns : 4;
    bool is_row_major : 1;
    bool is_array : 1;
    bool normalize : 1;
    type_descriptor(int td = 0) { *reinterpret_cast<int*>(this) = td; }
    type_descriptor(cgv::type::info::TypeId _coordinate_type, bool _normalize = false) : coordinate_type(_coordinate_type), element_type(ET_VALUE), nr_rows(1), nr_columns(1), is_row_major(false), is_array(false), normalize(_normalize) {}
    type_descriptor(cgv::type::info::TypeId _coordinate_type, unsigned _nr_entries, bool _normalize = false) : coordinate_type(_coordinate_type), element_type(ET_VECTOR), nr_rows(_nr_entries), nr_columns(1), is_row_major(false), is_array(false), normalize(_normalize) {}
    type_descriptor(cgv::type::info::TypeId _coordinate_type, unsigned _nr_rows, unsigned _nr_cols, bool _is_row_major, bool _normalize = false) : coordinate_type(_coordinate_type), element_type(ET_MATRIX), nr_rows(_nr_rows), nr_columns(_nr_cols), is_row_major(_is_row_major), is_array(false), normalize(_normalize) {}
    type_descriptor(const type_descriptor& td, bool _is_array) : coordinate_type(td.coordinate_type), element_type(td.element_type), nr_rows(td.nr_rows), nr_columns(td.nr_columns), is_row_major(td.is_row_major), normalize(td.normalize), is_array(_is_array) {}
    operator int() const { return *reinterpret_cast<const int*>(this); }
};
 
enum RenderAPI {
    RA_OPENGL,
    RA_DIRECTX
};
 
 
enum RenderPass {
    RP_NONE,                 
    RP_MAIN,                 
    RP_STEREO,               
    RP_SHADOW_MAP,           
    RP_SHADOW_VOLUME,        
    RP_OPAQUE_SURFACES,      
    RP_TRANSPARENT_SURFACES, 
    RP_PICK,                 
    RP_USER_DEFINED          
};
 
extern CGV_API std::string get_render_pass_name(RenderPass rp);
 
enum RenderPassFlags {
    RPF_NONE = 0,               
    RPF_SET_PROJECTION = 1,     
    RPF_SET_MODELVIEW = 1 << 1, 
    RPF_SET_MODELVIEW_PROJECTION =
          RPF_SET_PROJECTION | RPF_SET_MODELVIEW, 
    RPF_SET_LIGHTS = 1 << 2,                      
    RPF_SET_MATERIAL = 1 << 3,                    
    RPF_SET_LIGHTS_ON = 1 << 4,                   
    RPF_ENABLE_MATERIAL = 1 << 5,                 
    RPF_SET_LIGHTING =
          RPF_SET_LIGHTS | RPF_SET_LIGHTS_ON | RPF_ENABLE_MATERIAL, 
    RPF_CLEAR_COLOR = 1 << 6,                                       
    RPF_CLEAR_DEPTH = 1 << 7,                                       
    RPF_CLEAR_STENCIL = 1 << 8,                                     
    RPF_CLEAR_ACCUM = 1 << 9,                                       
    RPF_CLEAR_ALL =
          RPF_CLEAR_COLOR | RPF_CLEAR_DEPTH | RPF_CLEAR_STENCIL | RPF_CLEAR_ACCUM, 
    RPF_DRAWABLES_INIT_FRAME = 1 << 10,   
    RPF_SET_STATE_FLAGS = 1 << 11,        
    RPF_SET_CLEAR_COLOR = 1 << 12,        
    RPF_SET_CLEAR_DEPTH = 1 << 13,        
    RPF_SET_CLEAR_STENCIL = 1 << 14,      
    RPF_SET_CLEAR_ACCUM = 1 << 15,        
    RPF_DRAWABLES_DRAW = 1 << 16,         
    RPF_DRAWABLES_FINISH_FRAME = 1 << 17, 
    RPF_DRAW_TEXTUAL_INFO = 1 << 18,      
    RPF_DRAWABLES_AFTER_FINISH = 1 << 19, 
    RPF_HANDLE_SCREEN_SHOT = 1 << 20,     
    RPF_ALL = (1 << 21) - 1,              
    RPF_DEFAULT = RPF_ALL & ~(RPF_CLEAR_ACCUM | RPF_SET_CLEAR_ACCUM | RPF_CLEAR_STENCIL |
                              RPF_SET_CLEAR_STENCIL) 
};
 
enum MaterialSide {
    MS_NONE,
    MS_FRONT,
    MS_BACK,
    MS_FRONT_AND_BACK
};
 
enum IlluminationMode {
    IM_OFF,
    IM_ONE_SIDED,
    IM_TWO_SIDED
};
 
enum CullingMode {
    CM_OFF,
    CM_BACKFACE,
    CM_FRONTFACE
};
 
enum BlendFunction {
    BF_ZERO,
    BF_ONE,
    BF_SRC_COLOR,
    BF_ONE_MINUS_SRC_COLOR,
    BF_DST_COLOR,
    BF_ONE_MINUS_DST_COLOR,
    BF_SRC_ALPHA,
    BF_ONE_MINUS_SRC_ALPHA,
    BF_DST_ALPHA,
    BF_ONE_MINUS_DST_ALPHA,
    BF_CONSTANT_COLOR,
    BF_ONE_MINUS_CONSTANT_COLOR,
    BF_CONSTANT_ALPHA,
    BF_ONE_MINUS_CONSTANT_ALPHA,
    BF_SRC_ALPHA_SATURATE,
    BF_SRC1_COLOR,
    BF_ONE_MINUS_SRC1_COLOR,
    BF_SRC1_ALPHA,
    BF_ONE_MINUS_SRC1_ALPHA
};
 
enum TextureWrap {
    TW_REPEAT = 0, 
    TW_CLAMP = 1, 
    TW_CLAMP_TO_EDGE = 2, 
    TW_CLAMP_TO_BORDER = 3, 
    TW_MIRROR_CLAMP = 4, 
    TW_MIRROR_CLAMP_TO_EDGE = 5, 
    TW_MIRROR_CLAMP_TO_BORDER = 6,
    TW_MIRRORED_REPEAT = 7, 
    TW_LAST
};
 
extern CGV_API std::string to_string(TextureWrap wrap);
 
enum TextureFilter {
    TF_NEAREST = 0, 
    TF_LINEAR = 1, 
    TF_NEAREST_MIPMAP_NEAREST = 2, 
    TF_LINEAR_MIPMAP_NEAREST = 3, 
    TF_NEAREST_MIPMAP_LINEAR = 4,
    TF_LINEAR_MIPMAP_LINEAR = 5,
    TF_ANISOTROP = 6,
    TF_LAST
};
 
enum TextureType {
    TT_UNDEF, 
    TT_1D = 1,
    TT_2D,
    TT_3D,
    TT_1D_ARRAY,
    TT_2D_ARRAY,
    TT_CUBEMAP,
    TT_MULTISAMPLE_2D,
    TT_MULTISAMPLE_2D_ARRAY,
    TT_BUFFER
};
 
enum TextureCubeSides {
    TCS_PLUS_X,
    TCS_MINUS_X,
    TCS_PLUS_Y,
    TCS_MINUS_Y,
    TCS_PLUS_Z,
    TCS_MINUS_Z
};
 
enum PrimitiveType {
    PT_UNDEF,
    PT_POINTS,
    PT_LINES,
    PT_LINES_ADJACENCY,
    PT_LINE_STRIP,
    PT_LINE_STRIP_ADJACENCY,
    PT_LINE_LOOP,
    PT_TRIANGLES,
    PT_TRIANGLES_ADJACENCY,
    PT_TRIANGLE_STRIP,
    PT_TRIANGLE_STRIP_ADJACENCY,
    PT_TRIANGLE_FAN,
    PT_QUADS,
    PT_QUAD_STRIP,
    PT_POLYGON,
    PT_PATCHES,
    PT_LAST
};
 
enum TextureSampling
{
    TS_CELL = 0,   
    TS_VERTEX = 1  
};
 
enum CompareFunction
{
    CF_LEQUAL,
    CF_GEQUAL,
    CF_LESS,
    CF_GREATER,
    CF_EQUAL,
    CF_NOTEQUAL,
    CF_ALWAYS,
    CF_NEVER
};
 
enum AccessType {
    AT_READ_ONLY,
    AT_WRITE_ONLY,
    AT_READ_WRITE
};
 
enum TextAlignment {
    TA_NONE = 0,                           
    TA_LEFT = 1,                           
    TA_RIGHT = 2,                          
    TA_TOP = 4,                            
    TA_BOTTOM = 8,                         
    TA_TOP_LEFT = TA_LEFT + TA_TOP,        
    TA_TOP_RIGHT = TA_RIGHT + TA_TOP,      
    TA_BOTTOM_LEFT = TA_LEFT + TA_BOTTOM,  
    TA_BOTTOM_RIGHT = TA_RIGHT + TA_BOTTOM 
};
 
extern CGV_API std::string to_string(TextureFilter filter_type);
 
extern CGV_API std::string to_string(PrimitiveType pt);
 
extern CGV_API std::string to_string(TextureType tt);
 
extern CGV_API std::string to_string(TextureCubeSides tcs);
 
class CGV_API context;
 
class CGV_API render_component
{
public:
    void* handle;
    void* internal_format;
    void* user_data;
    const context* ctx_ptr;
    mutable std::string last_error;
    render_component();
    virtual bool is_created() const;
    void put_id_void(void* ptr) const;
    template <typename T>
    void put_id(T& id) const { put_id_void(&id); }
};
 
class CGV_API render_buffer_base : public render_component
{
public:
    unsigned nr_multi_samples = 0;
    render_buffer_base();
};
 
class CGV_API texture_base : public render_component
{
public:
    TextureFilter mag_filter;
    TextureFilter min_filter;
    TextureWrap   wrap_s;
    TextureWrap   wrap_t;
    TextureWrap   wrap_r;
    float anisotropy;
    float priority;
    float border_color[4];
    CompareFunction compare_function;
    bool use_compare_function;
    TextureType  tt;
    bool have_mipmaps;
    unsigned nr_multi_samples = 5;
    bool fixed_sample_locations = true;
    texture_base(TextureType _tt = TT_UNDEF);
};
 
 
class CGV_API shader_program_base : public render_component
{
protected:
    bool is_enabled;
    friend class context;
 
    bool auto_detect_uniforms;
    bool auto_detect_vertex_attributes;
 
    // uniforms
    bool uses_view;
    bool uses_material;
    bool uses_lights;
    bool uses_gamma;
    // maps uniform names to their locations in the shader program
    std::map<std::string, int> uniform_locations;
    
    // vertex attribute names
    int position_index;
    int color_index;
    bool context_sets_color;
    int normal_index;
    int texcoord_index;
 
public:
    PrimitiveType geometry_shader_input_type;
    PrimitiveType geometry_shader_output_type;
    int geometry_shader_output_count;
    shader_program_base();
    // configure program
    void specify_standard_uniforms(bool view, bool material, bool lights, bool gamma);
    void specify_standard_vertex_attribute_names(context& ctx, bool color = true, bool normal = true, bool texcoord = true);
    void specify_vertex_attribute_names(context& ctx, const std::string& position, const std::string& color = "", const std::string& normal = "", const std::string& texcoord = "");
    // uniforms
    bool does_use_view() const { return uses_view; }
    bool does_use_material() const { return uses_material; }
    bool does_use_lights() const { return uses_lights; }
    bool does_use_gamma() const { return uses_gamma; }
 
    // vertex attribute names
    void allow_context_to_set_color(bool allow);
    int get_position_index() const { return position_index; }
    int get_color_index() const { return color_index; }
    bool does_context_set_color() const { return context_sets_color; }
    int get_normal_index() const { return normal_index; }
    int get_texcoord_index() const { return texcoord_index; }
};
 
class CGV_API attribute_array_binding_base : public render_component
{
protected:
    bool is_enabled;
    friend class context;
public:
    attribute_array_binding_base();
};
 
 
enum VertexBufferType {
    VBT_UNDEF = -1,     
    VBT_VERTICES,       
    VBT_INDICES,        
    VBT_TEXTURE,        
    VBT_UNIFORM,        
    VBT_FEEDBACK,       
    VBT_STORAGE,        
    VBT_ATOMIC_COUNTER, 
    VBT_INDIRECT        
};
 
enum VertexBufferUsage {
    VBU_STREAM_DRAW,  
    VBU_STREAM_READ,  
    VBU_STREAM_COPY,  
    VBU_STATIC_DRAW,  
    VBU_STATIC_READ,  
    VBU_STATIC_COPY,  
    VBU_DYNAMIC_DRAW, 
    VBU_DYNAMIC_READ, 
    VBU_DYNAMIC_COPY  
};
 
class CGV_API vertex_buffer_base : public render_component
{
public:
    VertexBufferType type;
    VertexBufferUsage usage;
    vertex_buffer_base();
};
 
enum BufferTypeBits {
    BTB_COLOR_BIT = 1,            
    BTB_DEPTH_BIT = 2,            
    BTB_COLOR_AND_DEPTH_BITS = 3, 
    BTB_STENCIL_BIT = 4,          
    BTB_ALL_BITS = 7              
};
 
class CGV_API frame_buffer_base : public render_component
{
protected:
    friend class context;
    bool is_enabled;
    std::vector<int> enabled_color_attachments;
    bool depth_attached;
    bool attached[16];
    int width, height;
public:
    frame_buffer_base();
};
 
enum ShaderType { ST_DETECT, ST_COMPUTE, ST_VERTEX, ST_TESS_CONTROL, ST_TESS_EVALUATION, ST_GEOMETRY, ST_FRAGMENT };
 
enum FrameBufferType {
    FB_0 = 0,
    FB_1 = 1,
    FB_2 = 2,
    FB_3 = 3,
    FB_4 = 4,
    FB_5 = 5,
    FB_6 = 6,
    FB_7 = 7,
    FB_BACK =  128, 
    FB_FRONT = 129, 
    FB_LEFT =  512, 
    FB_RIGHT = 1024, 
    FB_BACK_LEFT  =  FB_BACK+FB_LEFT, 
    FB_BACK_RIGHT =  FB_BACK+FB_RIGHT, 
    FB_FRONT_LEFT  =  FB_FRONT+FB_LEFT, 
    FB_FRONT_RIGHT =  FB_FRONT+FB_RIGHT
};
 
// forward declaration of all render components
class CGV_API texture;
class CGV_API render_buffer;
class CGV_API frame_buffer;
class CGV_API shader_code;
class CGV_API shader_program;
 
// declare some colors by name
extern CGV_API float black[4], white[4], gray[4], green[4], brown[4], dark_red[4];
extern CGV_API float cyan[4], yellow[4], red[4], blue[4];
 
struct CGV_API context_config
{
    bool depth_buffer;
    bool double_buffer;
    bool alpha_buffer;
    bool stereo_buffer;
    bool stencil_buffer;
    bool accumulation_buffer;
    bool multi_sample_buffer;
    int depth_bits;
    int  stencil_bits;
    int  accumulation_bits;
    int  nr_multi_samples;
 
    int  version_major;
    int  version_minor;
    bool forward_compatible;
    bool debug;
    bool core_profile;
 
    context_config();
    bool self_reflect(cgv::reflect::reflection_handler& srh);
    std::vector<int> context_creation_attrib_list;
};
 
typedef cgv::data::ref_ptr<context_config> context_config_ptr;
 
struct CGV_API render_config : public cgv::base::base, public context_config
{
    int fullscreen_monitor;
    int window_width;
    int window_height;
 
    bool abort_on_error;
    bool dialog_on_error;
    bool show_error_on_console;
 
    render_config();
    std::string get_type_name() const;
    bool self_reflect(cgv::reflect::reflection_handler& srh);
};
 
typedef cgv::data::ref_ptr<render_config> render_config_ptr;
 
extern CGV_API render_config_ptr get_render_config();
 
struct window_transformation
{
    ivec4 viewport;
    dvec2 depth_range;
};
 
class CGV_API context : public context_config
{
protected:
    // store the GPU vendor id
    GPUVendorID gpu_vendor;
    // store the GPU device capabilities
    device_capabilities gpu_capabilities;
public:
    friend class CGV_API attribute_array_manager;
    friend class CGV_API render_component;
    friend class CGV_API texture;
    friend class CGV_API render_buffer;
    friend class CGV_API frame_buffer;
    friend class CGV_API shader_code;
    friend class CGV_API shader_program;
    friend class CGV_API attribute_array_binding;
    friend class CGV_API vertex_buffer;
 
    struct DepthTestState {
        bool enabled = false;
        CompareFunction test_func = CF_LESS;
    };
 
    struct BlendState {
        bool enabled = false;
        BlendFunction src_color = BF_ZERO;
        BlendFunction dst_color = BF_ZERO;
        BlendFunction src_alpha = BF_ZERO;
        BlendFunction dst_alpha = BF_ZERO;
        // TODO: Add blend equation?
    };
 
    struct BufferMask {
        bool depth_flag = true;
        bool red_flag = true;
        bool green_flag = true;
        bool blue_flag = true;
        bool alpha_flag = true;
    };
protected:
    friend class shader_program_base;
 
    bool use_shader_file_cache;
    bool auto_set_view_in_current_shader_program;
    bool auto_set_lights_in_current_shader_program;
    bool auto_set_material_in_current_shader_program;
    bool auto_set_gamma_in_current_shader_program;
    bool support_compatibility_mode;
    bool draw_in_compatibility_mode;
    bool debug_render_passes;
    bool enable_vsync;
    rgba current_color;
    bool sRGB_framebuffer;
    vec3 gamma3;
 
    std::stack<vec4> bg_color_stack;
    std::stack<float> bg_depth_stack;
    std::stack<int> bg_stencil_stack;
    std::stack<vec4> bg_accum_color_stack;
 
    std::stack<DepthTestState> depth_test_state_stack;
    std::stack<CullingMode> cull_state_stack;
    std::stack<BlendState> blend_state_stack;
    std::stack<BufferMask> buffer_mask_stack;
 
    std::stack<dmat4> modelview_matrix_stack, projection_matrix_stack;
    std::stack<std::vector<window_transformation>> window_transformation_stack;
    std::stack<frame_buffer_base*> frame_buffer_stack;
    std::stack<shader_program_base*> shader_program_stack;
public:
    shader_program_base* get_current_program() const;
    void enable_shader_file_cache();
    void disable_shader_file_cache();
    bool is_shader_file_cache_enabled() const;
protected:
    std::stack<attribute_array_binding_base*> attribute_array_binding_stack;
    struct light_source_status
    {
        bool enabled;
        vec3 eye_position;
        vec3 eye_spot_direction;
        int light_source_index;
    };
    std::vector<void*> enabled_light_source_handles;
    size_t light_source_handle;
    std::map<void*, std::pair<cgv::media::illum::light_source, light_source_status> > light_sources;
    virtual void on_lights_changed();
    static const unsigned nr_default_light_sources = 2;
    cgv::media::illum::light_source default_light_source[nr_default_light_sources];
    void* default_light_source_handles[nr_default_light_sources];
    cgv::media::illum::surface_material default_material;
    const cgv::media::illum::surface_material* current_material_ptr;
    bool current_material_is_textured;
    struct render_info
    {
        RenderPass pass;
        RenderPassFlags flags;
        void* user_data;
    };
    std::stack<render_info> render_pass_stack;
    RenderPassFlags default_render_flags;
    bool phong_shading;
    int current_background;
    int cursor_x, cursor_y;
    cgv::signal::callback_stream out_stream;
    float current_font_size;
    cgv::media::font::font_face_ptr current_font_face;
    int tab_size;
    int x_offset, y_offset;
    int nr_identations;
    bool at_line_begin;
    bool do_screen_shot;
    virtual void process_text(const std::string& text);
    virtual void draw_text(const std::string& text);
 
    virtual void destruct_render_objects();
    virtual void put_id(void* handle, void* ptr) const = 0;
 
    virtual cgv::data::component_format texture_find_best_format(const cgv::data::component_format& cf, render_component& rc, const std::vector<cgv::data::data_view>* palettes = 0) const = 0;
    virtual bool texture_create             (texture_base& tb, cgv::data::data_format& df) const = 0;
    virtual bool texture_create             (texture_base& tb, cgv::data::data_format& target_format, const cgv::data::const_data_view& data, int level, int cube_side = -1, int num_array_layers = 0, const std::vector<cgv::data::data_view>* palettes = 0) const = 0;
    virtual bool texture_create_from_buffer (texture_base& tb, cgv::data::data_format& df, int x, int y, int level) const = 0;
    virtual bool texture_replace            (texture_base& tb, int x, int y, int z_or_cube_side, const cgv::data::const_data_view& data, int level, const std::vector<cgv::data::data_view>* palettes = 0) const = 0;
    virtual bool texture_replace_from_buffer(texture_base& tb, int x, int y, int z_or_cube_side, int x_buffer, int y_buffer, unsigned int width, unsigned int height, int level) const = 0;
    virtual bool texture_create_mipmaps     (texture_base& tb, cgv::data::data_format& df) const = 0;
    virtual bool texture_generate_mipmaps   (texture_base& tb, unsigned int dim) const = 0;
    virtual bool texture_destruct           (texture_base& tb) const = 0;
    virtual bool texture_set_state          (const texture_base& tb) const = 0;
    virtual bool texture_enable             (texture_base& tb, int tex_unit, unsigned int nr_dims) const = 0;
    virtual bool texture_disable            (texture_base& tb, int tex_unit, unsigned int nr_dims) const = 0;
    virtual bool texture_bind_as_image      (texture_base& tb, int tex_unit, int level, bool bind_array, int layer, AccessType access) const = 0;
 
    virtual bool render_buffer_create       (render_buffer_base& rc, cgv::data::component_format& cf, int& _width, int& _height) const = 0;
    virtual bool render_buffer_destruct     (render_buffer_base& rc) const = 0;
 
    static void get_buffer_list(frame_buffer_base& fbb, bool& depth_buffer, std::vector<int>& buffers, int offset = 0);
    virtual bool frame_buffer_create           (frame_buffer_base& fbb) const;
    virtual bool frame_buffer_attach           (frame_buffer_base& fbb, const render_buffer_base& rb, bool is_depth, int i) const;
    virtual bool frame_buffer_attach           (frame_buffer_base& fbb, const texture_base& t, bool is_depth, int level, int i, int z) const;
    virtual bool frame_buffer_is_complete(const frame_buffer_base& fbb) const = 0;
    virtual bool frame_buffer_enable           (frame_buffer_base& fbb);
    virtual bool frame_buffer_disable          (frame_buffer_base& fbb);
    virtual bool frame_buffer_destruct(frame_buffer_base& fbb) const;
    virtual void frame_buffer_blit(const frame_buffer_base* src_fbb_ptr, const ivec4& S, frame_buffer_base* dst_fbb_ptr, const ivec4& _D, BufferTypeBits btbs, bool interpolate) const = 0;
    virtual int frame_buffer_get_max_nr_color_attachments() const = 0;
    virtual int frame_buffer_get_max_nr_draw_buffers() const = 0;
 
    virtual bool shader_code_create  (render_component& sc, ShaderType st, const std::string& source) const = 0;
    virtual bool shader_code_compile (render_component& sc) const = 0;
    virtual void shader_code_destruct(render_component& sc) const = 0;
 
    virtual bool shader_program_create   (shader_program_base& spb) const = 0;
    virtual void shader_program_attach(shader_program_base& spb, const render_component& sc) const = 0;
    virtual void shader_program_detach(shader_program_base& spb, const render_component& sc) const = 0;
    virtual bool shader_program_link(shader_program_base& spb) const;
    virtual bool shader_program_set_state(shader_program_base& spb) const = 0;
    virtual bool shader_program_enable   (shader_program_base& spb);
    virtual bool shader_program_disable(shader_program_base& spb);
    virtual bool shader_program_destruct(shader_program_base& spb) const;
    virtual void shader_program_set_uniform_locations(shader_program_base& spb) const;
    virtual bool shader_program_get_active_uniforms(shader_program_base& spb, std::vector<std::string>& names) const = 0;
    virtual int  get_uniform_location(const shader_program_base& spb, const std::string& name) const = 0;
    virtual bool set_uniform_void(shader_program_base& spb, int loc, type_descriptor value_type, const void* value_ptr) const = 0;
    virtual bool set_uniform_array_void(shader_program_base& spb, int loc, type_descriptor value_type, const void* value_ptr, size_t nr_elements) const = 0;
    virtual int  get_attribute_location(const shader_program_base& spb, const std::string& name) const = 0;
    virtual bool set_attribute_void(shader_program_base& spb, int loc, type_descriptor value_type, const void* value_ptr) const = 0;
 
    virtual bool attribute_array_binding_create  (attribute_array_binding_base& aab) const = 0;
    virtual bool attribute_array_binding_destruct(attribute_array_binding_base& aab) const;
    virtual bool attribute_array_binding_enable  (attribute_array_binding_base& aab);
    virtual bool attribute_array_binding_disable (attribute_array_binding_base& aab);
    virtual bool set_attribute_array_void(attribute_array_binding_base* aab, int loc, type_descriptor value_type, const vertex_buffer_base* vbb, const void* ptr, size_t nr_elements = 0, unsigned stride_in_bytes = 0) const = 0;
    virtual bool set_element_array(attribute_array_binding_base* aab, const vertex_buffer_base* vbb) const = 0;
    virtual bool enable_attribute_array(attribute_array_binding_base* aab, int loc, bool do_enable) const = 0;
    virtual bool is_attribute_array_enabled(const attribute_array_binding_base* aab, int loc) const = 0;
 
    virtual bool vertex_buffer_bind(const vertex_buffer_base& vbb, VertexBufferType _type, unsigned _idx = -1) const = 0;
    virtual bool vertex_buffer_unbind(const vertex_buffer_base& vbb, VertexBufferType _type, unsigned _idx = -1) const = 0;
    virtual bool vertex_buffer_create(vertex_buffer_base& vbb, const void* array_ptr, size_t size_in_bytes) const = 0;
    virtual bool vertex_buffer_resize(vertex_buffer_base& vbb, const void* array_ptr, size_t size_in_bytes) const = 0;
    virtual bool vertex_buffer_replace(vertex_buffer_base& vbb, size_t offset, size_t size_in_bytes, const void* array_ptr) const = 0;
    virtual bool vertex_buffer_copy(const vertex_buffer_base& src, size_t src_offset, vertex_buffer_base& target, size_t target_offset, size_t size_in_bytes) const = 0;
    virtual bool vertex_buffer_copy_back(vertex_buffer_base& vbb, size_t offset, size_t size_in_bytes, void* array_ptr) const = 0;
    virtual bool vertex_buffer_destruct(vertex_buffer_base& vbb) const = 0;
public:
    context();
    virtual ~context();
    virtual void error(const std::string& message, const render_component* rc = 0) const;
    virtual GPUVendorID get_gpu_vendor_id() const;
    const device_capabilities& get_device_capabilities() const;
 
    virtual void init_render_pass();
    virtual void draw_textual_info();
    virtual void perform_screen_shot();
    virtual void finish_render_pass();
 
    virtual void configure_new_child(cgv::base::base_ptr child);
    virtual RenderAPI get_render_api() const = 0;
    unsigned get_render_pass_recursion_depth() const;
    virtual RenderPass get_render_pass() const;
    virtual RenderPassFlags get_render_pass_flags() const;
    virtual void* get_render_pass_user_data() const;
    virtual RenderPassFlags get_default_render_pass_flags() const;
    virtual void set_default_render_pass_flags(RenderPassFlags);
    virtual void render_pass(RenderPass render_pass = RP_MAIN, 
                             RenderPassFlags render_pass_flags = RPF_ALL,
                             void* user_data = 0);
    void set_debug_render_passes(bool _debug);
    bool get_debug_render_passes() const { return debug_render_passes; }
    virtual bool in_render_process() const = 0;
    virtual bool is_created() const = 0;
    virtual bool is_current() const = 0;
    virtual bool recreate_context();
    virtual bool make_current() const = 0;
    virtual void clear_current() const = 0;
    virtual void attach_alpha_buffer(bool attach = true) = 0;
    virtual void attach_depth_buffer(bool attach = true) = 0;
    virtual void attach_stencil_buffer(bool attach = true) = 0;
    virtual bool is_stereo_buffer_supported() const = 0;
    virtual void attach_stereo_buffer(bool attach = true) = 0;
    virtual void attach_accumulation_buffer(bool attach = true) = 0;
    virtual void attach_multi_sample_buffer(bool attach = true) = 0;
 
    virtual unsigned int get_width() const = 0;
    virtual unsigned int get_height() const = 0;
    virtual void resize(unsigned int width, unsigned int height) = 0;
 
 
    virtual bool read_frame_buffer(
        data::data_view& dv, 
        unsigned int x = 0, unsigned int y = 0, 
        FrameBufferType buffer_type = FB_BACK,
        cgv::type::info::TypeId type = cgv::type::info::TI_UINT8,
        data::ComponentFormat cf = data::CF_RGB,
        int w = -1, int h = -1) = 0;
    bool write_frame_buffer_to_image(
        const std::string& file_name, 
        data::ComponentFormat cf = data::CF_RGB,
        FrameBufferType buffer_type = FB_BACK,
        unsigned int x = 0, unsigned int y = 0, 
        int w = -1, int h = -1,
        float depth_offset = 0.9f, float depth_scale = 10.0f);
 
    void push_bg_color();
    void pop_bg_color();
    virtual void set_bg_color(vec4 rgba);
    void set_bg_color(float r, float g, float b, float a);
    vec4 get_bg_color() const;
    void put_bg_color(float* rgba) const;
    void set_bg_alpha(float a);
    float get_bg_alpha() const;
    void set_bg_clr_idx(unsigned int idx);
    unsigned int get_bg_clr_idx() const;
    
    void push_bg_depth();
    void pop_bg_depth();
    virtual void set_bg_depth(float d);
    float get_bg_depth() const;
 
    void push_bg_stencil();
    void pop_bg_stencil();
    virtual void set_bg_stencil(int s);
    int get_bg_stencil() const;
 
    void push_bg_accum_color();
    void pop_bg_accum_color();
    virtual void set_bg_accum_color(vec4 rgba);
    void set_bg_accum_color(float r, float g, float b, float a);
    vec4 get_bg_accum_color() const;
    void put_bg_accum_color(float* rgba) const;
    void set_bg_accum_alpha(float a);
    float get_bg_accum_alpha() const;
 
    virtual void clear_background(bool color_flag, bool depth_flag, bool stencil_flag = false, bool accum_flag = false) = 0;
 
    virtual void post_redraw() = 0;
    virtual void force_redraw() = 0;
    virtual void announce_external_frame_buffer_change(void*& cgv_fbo_storage) = 0;
    virtual void recover_from_external_frame_buffer_change(void* cgv_fbo_storage) = 0;
 
    virtual void enable_font_face(media::font::font_face_ptr font_face, float font_size);
    virtual float get_current_font_size() const;
    virtual media::font::font_face_ptr get_current_font_face() const;
 
    DEPRECATED("deprecated and ignored.") virtual void enable_phong_shading();
    DEPRECATED("deprecated and ignored.") virtual void disable_phong_shading();
    DEPRECATED("deprecated, use set_material instead.") virtual void enable_material(const cgv::media::illum::phong_material& mat = cgv::media::illum::default_material(), MaterialSide ms = MS_FRONT_AND_BACK, float alpha = 1);
    DEPRECATED("deprecated and ignored.") virtual void disable_material(const cgv::media::illum::phong_material& mat = cgv::media::illum::default_material());
    DEPRECATED("deprecated, use enable_material(textured_surface_material) instead.") virtual void enable_material(const textured_material& mat, MaterialSide ms = MS_FRONT_AND_BACK, float alpha = 1);
    //DEPRECATED("deprecated, use disable_material(textured_surface_material) instead.") virtual void disable_material(const textured_material& mat) = 0;
    void set_gamma(float _gamma);
    virtual void set_gamma3(const vec3& _gamma3);
    float get_gamma() const { return (gamma3.x() + gamma3.y() + gamma3.z()) / 3.0f; }
    vec3 get_gamma3() const { return gamma3; }
    virtual void enable_sRGB_framebuffer(bool do_enable = true);
    bool sRGB_framebuffer_enabled() { return sRGB_framebuffer; }
    const rgba& get_color() const;
    virtual void set_color(const rgba& clr);
    virtual void set_color(const rgb& clr, float opacity = 1.0f) { set_color(rgba(clr[0], clr[1], clr[2], opacity)); }
    virtual void set_material(const cgv::media::illum::surface_material& mat);
    const cgv::media::illum::surface_material* get_current_material() const;
    virtual void set_textured_material(const textured_material& mat);
    virtual void enable_material(textured_material& mat) = 0;
    virtual void disable_material(textured_material& mat) = 0;
    void set_current_gamma(shader_program& prog) const;
    void set_current_view(shader_program& prog, bool modelview_deps = true, bool projection_deps = true) const;
    void set_current_material(shader_program& prog) const;
    void set_current_lights(shader_program& prog) const;
    vec3 get_light_eye_position(const cgv::media::illum::light_source& light, bool place_now) const;
    vec3 get_light_eye_spot_direction(const cgv::media::illum::light_source& light, bool place_now) const;
    virtual shader_program& ref_default_shader_program(bool texture_support = false) = 0;
    virtual shader_program& ref_surface_shader_program(bool texture_support = false) = 0;
    virtual void enumerate_program_uniforms(shader_program& prog, std::vector<std::string>& names, std::vector<int>* locations_ptr = 0, std::vector<int>* sizes_ptr = 0, std::vector<int>* types_ptr = 0, bool show = false) const = 0;
    virtual void enumerate_program_attributes(shader_program& prog, std::vector<std::string>& names, std::vector<int>* locations_ptr = 0, std::vector<int>* sizes_ptr = 0, std::vector<int>* types_ptr = 0, bool show = false) const = 0;
 
    DEPRECATED("deprecated, use add_light_source instead.") void* enable_light(const cgv::media::illum::light_source& light) { return add_light_source(light); }
    DEPRECATED("deprecated, use enable_light_source instead.") void disable_light(void* handle) { disable_light_source(handle); }
    DEPRECATED("deprecated, use get_max_nr_enabled_light_sources instead.") unsigned get_max_nr_lights() const { return get_max_nr_enabled_light_sources(); }
    size_t get_nr_light_sources() const;
    void* add_light_source(const cgv::media::illum::light_source& light, bool enabled = true, bool place_now = false);
    bool remove_light_source(void* handle);
    const cgv::media::illum::light_source& get_light_source(void* handle) const;
    const light_source_status& get_light_source_status(void* handle) const;
    void set_light_source(void* handle, const cgv::media::illum::light_source& light, bool place_now = true);
    void place_light_source(void* handle);
 
    virtual unsigned get_max_nr_enabled_light_sources() const;
    size_t get_nr_enabled_light_sources() const;
    void* get_enabled_light_source_handle(size_t i) const;
    bool is_light_source_enabled(void* handle);
    bool enable_light_source(void* handle);
    bool disable_light_source(void* handle);
    size_t get_nr_default_light_sources() const { return nr_default_light_sources; }
    const cgv::media::illum::light_source& get_default_light_source(size_t i) const;
    void set_default_light_source(size_t i, const cgv::media::illum::light_source& ls);
 
    virtual std::ostream& output_stream();
    virtual void set_cursor(int x, int y);
    virtual void get_cursor(int& x, int& y) const;
    virtual void put_cursor_coords(const vecn& p, int& x, int& y) const;
    virtual void set_cursor(const vecn& pos, 
        const std::string& text = "", TextAlignment ta = TA_BOTTOM_LEFT,
        int x_offset=0, int y_offset=0);
 
    virtual void draw_edges_of_faces(
        const float* vertices, const float* normals, const float* tex_coords,
        const int* vertex_indices, const int* normal_indices, const int* tex_coord_indices, 
        int nr_faces, int face_degree, bool flip_normals = false) const = 0;
    virtual void draw_edges_of_strip_or_fan(
        const float* vertices, const float* normals, const float* tex_coords,
        const int* vertex_indices, const int* normal_indices, const int* tex_coord_indices, 
        int nr_faces, int face_degree, bool is_fan, bool flip_normals = false) const = 0;
    virtual void draw_faces(
        const float* vertices, const float* normals, const float* tex_coords,
        const int* vertex_indices, const int* normal_indices, const int* tex_coord_indices,
        int nr_faces, int face_degree, bool flip_normals = false) const = 0;
    virtual void draw_strip_or_fan(
        const float* vertices, const float* normals, const float* tex_coords,
        const int* vertex_indices, const int* normal_indices, const int* tex_coord_indices,
        int nr_faces, int face_degree, bool is_fan, bool flip_normals = false) const = 0;
 
    void tesselate_unit_square(bool flip_normals = false, bool edges = false);
    void tesselate_unit_cube(bool flip_normals = false, bool edges = false);
    virtual void tesselate_box(const cgv::media::axis_aligned_box<double, 3>& B, bool flip_normals, bool edges = false) const;
    void tesselate_unit_prism(bool flip_normals = false, bool edges = false);
    void tesselate_unit_disk(int resolution = 25, bool flip_normals = false, bool edges = false);
    void tesselate_unit_cone(int resolution = 25, bool flip_normals = false, bool edges = false);
    void tesselate_unit_cylinder(int resolution = 25, bool flip_normals = false, bool edges = false);
    void tesselate_unit_sphere(int resolution = 25, bool flip_normals = false, bool edges = false);
    void tesselate_unit_tetrahedron(bool flip_normals = false, bool edges = false);
    void tesselate_unit_octahedron(bool flip_normals = false, bool edges = false);
    void tesselate_unit_dodecahedron(bool flip_normals = false, bool edges = false);
    void tesselate_unit_icosahedron(bool flip_normals = false, bool edges = false);
    void tesselate_unit_torus(float minor_radius = 0.2f, int resolution = 25, bool flip_normals = false, bool edges = false);
 
    virtual void tesselate_arrow(double length = 1, double aspect = 0.1, double rel_tip_radius = 2.0, double tip_aspect = 0.3, int res = 25, bool edges = false);
    virtual void tesselate_arrow(const dvec3& start, const dvec3& end, double aspect = 0.1f, double rel_tip_radius = 2.0f, double tip_aspect = 0.3f, int res = 25, bool edges = false);
 
    virtual void draw_light_source(const cgv::media::illum::light_source& l, float intensity_scale, float light_scale); 
 
 
    void push_depth_test_state();
    void pop_depth_test_state();
    DepthTestState get_depth_test_state() const;
    virtual void set_depth_test_state(DepthTestState state);
    virtual void set_depth_func(CompareFunction func);
    virtual void enable_depth_test();
    virtual void disable_depth_test();
 
    void push_cull_state();
    void pop_cull_state();
    CullingMode get_cull_state() const;
    virtual void set_cull_state(CullingMode culling_mode);
 
    void push_blend_state();
    void pop_blend_state();
    BlendState get_blend_state() const;
    virtual void set_blend_state(BlendState state);
    virtual void set_blend_func(BlendFunction src_factor, BlendFunction dst_factor);
    virtual void set_blend_func_separate(BlendFunction src_color_factor, BlendFunction dst_color_factor, BlendFunction src_alpha_factor, BlendFunction dst_alpha_factor);
    void set_blend_func_front_to_back();
    void set_blend_func_back_to_front();
    virtual void enable_blending();
    virtual void disable_blending();
 
    void push_buffer_mask();
    void pop_buffer_mask();
    BufferMask get_buffer_mask() const;
    virtual void set_buffer_mask(BufferMask mask);
    bool get_depth_mask() const;
    virtual void set_depth_mask(bool flag);
    bvec4 get_color_mask() const;
    virtual void set_color_mask(bvec4 flags);
 
 
    DEPRECATED("deprecated: use get_modelview_matrix() instead.") dmatn get_V() const { return dmatn(4,4,&get_modelview_matrix()(0,0)); }
    DEPRECATED("deprecated: use set_modelview_matrix() instead.") void set_V(const dmatn& V) const { const_cast<context*>(this)->set_modelview_matrix(dmat4(4,4,&V(0,0))); }
    DEPRECATED("deprecated: use push_modelview_matrix() instead.") void push_V() { push_modelview_matrix(); }
    DEPRECATED("deprecated: use pop_modelview_matrix() instead.") void pop_V() { pop_modelview_matrix(); }
    DEPRECATED("deprecated: use get_projection_matrix() instead.") dmatn get_P() const { return dmatn(4, 4, &get_projection_matrix()(0, 0)); }
    DEPRECATED("deprecated: use set_projection_matrix() instead.") void set_P(const dmatn& P) const { const_cast<context*>(this)->set_projection_matrix(dmat4(4,4,&P(0, 0))); }
    DEPRECATED("deprecated: use push_projection_matrix() instead.") void push_P() { push_projection_matrix(); }
    DEPRECATED("deprecated: use pop_projection_matrix() instead.") void pop_P() { pop_projection_matrix(); }
    DEPRECATED("deprecated: use get_device_matrix() instead.")  dmatn get_D() const { return dmatn(4, 4, &get_window_matrix()(0, 0)); }
    DEPRECATED("deprecated: use get_modelview_projection_device_matrix() instead.") dmatn get_DPV() const { return dmatn(4, 4, &get_modelview_projection_window_matrix()(0, 0)); }
    virtual void push_pixel_coords() = 0;
    virtual void pop_pixel_coords() = 0;
    virtual dmat4 get_modelview_matrix() const = 0;
    virtual void set_modelview_matrix(const dmat4& MV);
    virtual void mul_modelview_matrix(const dmat4& MV);
 
    void push_modelview_matrix();
    void pop_modelview_matrix();
    virtual dmat4 get_projection_matrix() const = 0;
    virtual void set_projection_matrix(const dmat4& P);
    virtual void mul_projection_matrix(const dmat4& P);
    void push_projection_matrix();
    void pop_projection_matrix();
    void push_window_transformation_array();
 
    virtual void pop_window_transformation_array();
    virtual void announce_external_viewport_change(ivec4& cgv_viewport_storage) = 0;
    virtual void recover_from_external_viewport_change(const ivec4& cgv_viewport_storage) = 0;
    virtual unsigned get_max_window_transformation_array_size() const = 0;
 
protected:
    bool ensure_window_transformation_index(int& array_index);
public:
 
    virtual void set_viewport(const ivec4& viewport, int array_index = -1);
 
    virtual void set_depth_range(const dvec2& depth_range = dvec2(0, 1), int array_index = -1);
    const std::vector<window_transformation>& get_window_transformation_array() const;
 
    dmat4 get_window_matrix(unsigned array_index = 0) const;
    dmat4 get_modelview_projection_window_matrix(unsigned array_index = 0) const;
    virtual double get_window_z(int x_window, int y_window) const = 0;
 
    inline vec3 get_model_point(int x_window, int y_window) const { 
        return get_model_point(x_window, y_window, get_window_z(x_window, y_window)); 
    }
 
    inline vec3 get_model_point(int x_window, int y_window, double z_window) const {
        return get_model_point(x_window, y_window, z_window, get_modelview_projection_window_matrix());
    }
 
    inline vec3 get_model_point(int x_window, int y_window, const dmat4& modelview_projection_window_matrix) const {
        return get_model_point(x_window, y_window, get_window_z(x_window, y_window), modelview_projection_window_matrix);
    }
 
    inline static vec3 get_model_point(int x_window, int y_window, double z_window, const dmat4& modelview_projection_window_matrix) {
        return get_model_point(dvec3(x_window+0.5, y_window+0.5, z_window), modelview_projection_window_matrix);
    }
 
    inline vec3 get_model_point(const vec3& p_window) const {
        return get_model_point(p_window, get_modelview_projection_window_matrix());
    }
 
    static vec3 get_model_point(const dvec3& p_window, const dmat4& modelview_projection_window_matrix);
    DEPRECATED("use get_window_matrix() instead.") dmat4 get_device_matrix() const { return get_window_matrix(); }
    DEPRECATED("use get_modelview_projection_window_matrix() instead.") dmat4 get_modelview_projection_device_matrix() const;
    DEPRECATED("use get_window_z()") double get_z_D(int x_D, int y_D) const { return get_window_z(x_D, y_D); }
    DEPRECATED("use get_model_point()") vec3 get_point_W(int x_D, int y_D) const { return get_model_point(x_D, y_D); }
    DEPRECATED("use get_model_point()") vec3 get_point_W(int x_D, int y_D, const dmat4& MPD) const { return get_model_point(x_D, y_D, MPD); }
    DEPRECATED("use get_model_point()") vec3 get_point_W(int x_D, int y_D, double z_D) const { return get_model_point(x_D, y_D, z_D); }
    DEPRECATED("use get_model_point()") vec3 get_point_W(int x_D, int y_D, double z_D, const dmat4& MPD) const { return get_model_point(x_D, y_D, z_D, MPD); }
    DEPRECATED("use get_model_point()") vec3 get_point_W(const vec3& p_D) const { return get_model_point(p_D); }
    DEPRECATED("use get_model_point()") vec3 get_point_W(const vec3& p_D, const dmat4& MPD) const { return get_model_point(p_D, MPD); }
};
 
extern CGV_API context* create_context(RenderAPI api = RA_OPENGL, 
        unsigned int w = 800, unsigned int h = 600, 
        const std::string& title = "", bool show = false);
 
typedef context* (*context_creation_function_type)(RenderAPI api, unsigned int w, unsigned int h, const std::string& title, bool show);
 
extern CGV_API void register_context_factory(context_creation_function_type);
 
struct CGV_API context_factory_registration
{
    context_factory_registration(context_creation_function_type fp);
};
 
    }
}
 
#include <cgv/config/lib_end.h>