cgv/context_8h_source.html

#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

};


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;


    // 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

};


enum ContextIntegerConstant {

    MAX_NR_GEOMETRY_SHADER_OUTPUT_VERTICES

};


// 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;

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 int query_integer_constant(ContextIntegerConstant cic) const = 0;

    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 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;


    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>

cgv::base::base
base class for all classes that can be registered with support for dynamic properties (see also secti...
Definition base.h:75

cgv::data::component_format
the component format inherits the information of a packing_info and adds information on the component...
Definition component_format.h:56

cgv::data::const_data_view
The const_data_view has the functionality of the data_view but uses a const pointer and therefore doe...
Definition data_view.h:221

cgv::data::data_format
A data_format describes a multidimensional data block of data entries.
Definition data_format.h:17

cgv::data::data_view
the data view gives access to a data array of one, two, three or four dimensions.
Definition data_view.h:153

cgv::data::ref_ptr
reference counted pointer, which can work together with types that are derived from ref_counted,...
Definition ref_ptr.h:160

cgv::math::fmat
matrix of fixed size dimensions
Definition fmat.h:23

cgv::math::fvec< int32_t, 4 >

cgv::math::fvec::z
T & z()
third element
Definition fvec.h:163

cgv::math::fvec::y
T & y()
second element
Definition fvec.h:159

cgv::math::fvec::x
T & x()
first element
Definition fvec.h:155

cgv::math::mat
A matrix type (full column major storage) The matrix can be loaded directly into OpenGL without need ...
Definition mat.h:208

cgv::math::vec< float >

cgv::media::axis_aligned_box
An axis aligned box, defined by to points: min and max.
Definition axis_aligned_box.h:15

cgv::media::color< float, cgv::media::RGB, cgv::media::OPACITY >

cgv::media::illum::light_source
>simple class to hold the properties of a light source
Definition light_source.h:17

cgv::media::illum::surface_material
simple class to hold the material properties of a phong material
Definition surface_material.h:26

cgv::reflect::reflection_handler
the self reflection handler is passed to the virtual self_reflect() method of cgv::base::base.
Definition reflection_handler.h:63

cgv::render::attribute_array_binding_base
base class for attribute_array_bindings
Definition context.h:403

cgv::render::attribute_array_binding
the attribute_array_binding allows to define vertex attributes (i.e.
Definition attribute_array_binding.h:20

cgv::render::attribute_array_manager
attribute array manager used to upload arrays to gpu
Definition attribute_array_manager.h:14

cgv::render::context
base class for all drawables, which is independent of the used rendering API.
Definition context.h:621

cgv::render::context::announce_external_viewport_change
virtual void announce_external_viewport_change(ivec4 &cgv_viewport_storage)=0
announce an external viewport change performed with rendering API to the cgv framework providing spac...

cgv::render::context::read_frame_buffer
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
read the current frame buffer or a rectangular region of it into the given data view.

cgv::render::context::get_model_point
vec3 get_model_point(int x_window, int y_window, const dmat4 &modelview_projection_window_matrix) const
compute model space 3D point from the given opengl pixel location (window location) and modelview_pro...
Definition context.h:1435

cgv::render::context::gamma3
vec3 gamma3
per color channel gamma value passed to shader programs that have gamma uniform
Definition context.h:698

cgv::render::context::in_render_process
virtual bool in_render_process() const =0
return whether the context is currently in process of rendering

cgv::render::context::is_created
virtual bool is_created() const =0
return whether the context is created

cgv::render::context::draw_edges_of_faces
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
pass geometry of given faces to current shader program and generate draw calls to render lines for th...

cgv::render::context::recover_from_external_viewport_change
virtual void recover_from_external_viewport_change(const ivec4 &cgv_viewport_storage)=0
restore cgv viewport to the state before the external change

cgv::render::context::default_render_flags
RenderPassFlags default_render_flags
default render flags with which the main render pass is initialized
Definition context.h:776

cgv::render::context::announce_external_frame_buffer_change
virtual void announce_external_frame_buffer_change(void *&cgv_fbo_storage)=0
announce an external frame buffer change performed with rendering API to the cgv framework providing ...

cgv::render::context::get_model_point
vec3 get_model_point(int x_window, int y_window) const
compute model space 3D point from the given opengl pixel location (window location)
Definition context.h:1423

cgv::render::context::render_pass_stack
std::stack< render_info > render_pass_stack
store the current render pass
Definition context.h:774

cgv::render::context::enumerate_program_uniforms
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
get list of program uniforms

cgv::render::context::draw_edges_of_strip_or_fan
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
pass geometry of given strip or fan to current shader program and generate draw calls to render lines...

cgv::render::context::current_font_size
float current_font_size
store current font size
Definition context.h:786

cgv::render::context::enable_vsync
bool enable_vsync
whether vsync should be enabled
Definition context.h:692

cgv::render::context::disable_material
virtual void disable_material(textured_material &mat)=0
disable a material with textures

cgv::render::context::attach_alpha_buffer
virtual void attach_alpha_buffer(bool attach=true)=0
attach or detach (attach=false) an alpha buffer to the current frame buffer if not present

cgv::render::context::attach_stencil_buffer
virtual void attach_stencil_buffer(bool attach=true)=0
attach or detach (attach=false) stencil buffer to the current frame buffer if not present

cgv::render::context::buffer_mask_stack
std::stack< BufferMask > buffer_mask_stack
stack of buffer masks
Definition context.h:716

cgv::render::context::draw_strip_or_fan
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
pass geometry of given strip or fan to current shader program and generate draw calls to render trian...

cgv::render::context::is_current
virtual bool is_current() const =0
return whether the context is current

cgv::render::context::auto_set_lights_in_current_shader_program
bool auto_set_lights_in_current_shader_program
whether to automatically set lights in current shader program, defaults to true
Definition context.h:680

cgv::render::context::light_source_handle
size_t light_source_handle
counter to construct light source handles
Definition context.h:749

cgv::render::context::attach_stereo_buffer
virtual void attach_stereo_buffer(bool attach=true)=0
attach or detach (attach=false) stereo buffer to the current frame buffer if not present

cgv::render::context::shader_program_stack
std::stack< shader_program_base * > shader_program_stack
stack of currently enabled shader programs
Definition context.h:725

cgv::render::context::get_width
virtual unsigned int get_width() const =0
return the width of the window

cgv::render::context::get_nr_default_light_sources
size_t get_nr_default_light_sources() const
return number of default light sources
Definition context.h:1158

cgv::render::context::set_color
virtual void set_color(const rgb &clr, float opacity=1.0f)
set the current color
Definition context.h:1092

cgv::render::context::ref_default_shader_program
virtual shader_program & ref_default_shader_program(bool texture_support=false)=0
return a reference to a shader program used to render without illumination

cgv::render::context::current_background
int current_background
current back ground color index
Definition context.h:780

cgv::render::context::clear_background
virtual void clear_background(bool color_flag, bool depth_flag, bool stencil_flag=false, bool accum_flag=false)=0
clear the buffer contents of the flagged buffers to the set background colors

cgv::render::context::is_stereo_buffer_supported
virtual bool is_stereo_buffer_supported() const =0
return whether the graphics card supports stereo buffer mode

cgv::render::context::resize
virtual void resize(unsigned int width, unsigned int height)=0
resize the context to the given dimensions

cgv::render::context::get_height
virtual unsigned int get_height() const =0
return the height of the window

cgv::render::context::get_gamma3
vec3 get_gamma3() const
query current per color channel gamma
Definition context.h:1082

cgv::render::context::get_model_point
vec3 get_model_point(const vec3 &p_window) const
compute model space 3D point from the given window space point
Definition context.h:1447

cgv::render::context::draw_faces
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
pass geometry of given faces to current shader program and generate draw calls to render triangles

cgv::render::context::modelview_matrix_stack
std::stack< dmat4 > modelview_matrix_stack
keep two matrix stacks for model view and projection matrices
Definition context.h:719

cgv::render::context::use_shader_file_cache
bool use_shader_file_cache
whether to use the caching facilities of shader_program and shader_code to store loaded shader file c...
Definition context.h:676

cgv::render::context::get_window_z
virtual double get_window_z(int x_window, int y_window) const =0
read the window z-coordinate from the depth buffer for the given opengl x- and y-coordinates

cgv::render::context::nr_identations
int nr_identations
current number of indentations
Definition context.h:794

cgv::render::context::clear_current
virtual void clear_current() const =0
clear the current context, typically used in multi-threaded rendering to allow usage of context in se...

cgv::render::context::auto_set_material_in_current_shader_program
bool auto_set_material_in_current_shader_program
whether to automatically set material in current shader program, defaults to true
Definition context.h:682

cgv::render::context::recover_from_external_frame_buffer_change
virtual void recover_from_external_frame_buffer_change(void *cgv_fbo_storage)=0
restore cgv frame buffer to the state before the external change

cgv::render::context::get_model_point
static vec3 get_model_point(int x_window, int y_window, double z_window, const dmat4 &modelview_projection_window_matrix)
compute model space 3D point from the given opengl pixel location (window location) with the given mo...
Definition context.h:1441

cgv::render::context::get_render_api
virtual RenderAPI get_render_api() const =0
return the used rendering API

cgv::render::context::bg_depth_stack
std::stack< float > bg_depth_stack
stack of background depth values
Definition context.h:703

cgv::render::context::support_compatibility_mode
bool support_compatibility_mode
whether to support view and lighting management of compatibility mode, defaults to true
Definition context.h:686

cgv::render::context::attribute_array_binding_stack
std::stack< attribute_array_binding_base * > attribute_array_binding_stack
stack of currently enabled attribute array binding
Definition context.h:737

cgv::render::context::depth_test_state_stack
std::stack< DepthTestState > depth_test_state_stack
stack of depth test states
Definition context.h:710

cgv::render::context::cull_state_stack
std::stack< CullingMode > cull_state_stack
stack of culling mode states
Definition context.h:712

cgv::render::context::phong_shading
bool phong_shading
whether to use phong shading
Definition context.h:778

cgv::render::context::push_pixel_coords
virtual void push_pixel_coords()=0
use this to push new modelview and new projection matrices onto the transformation stacks such that x...

cgv::render::context::force_redraw
virtual void force_redraw()=0
the context will be redrawn right now. This method cannot be called inside the following methods of a...

cgv::render::context::current_material_is_textured
bool current_material_is_textured
store flag to tell whether current material is textured
Definition context.h:765

cgv::render::context::current_color
rgba current_color
current color value
Definition context.h:694

cgv::render::context::bg_stencil_stack
std::stack< int > bg_stencil_stack
stack of background stencil values
Definition context.h:705

cgv::render::context::get_projection_matrix
virtual dmat4 get_projection_matrix() const =0
return homogeneous 4x4 projection matrix, which transforms from eye to clip space

cgv::render::context::tab_size
int tab_size
size a tabs
Definition context.h:790

cgv::render::context::bg_accum_color_stack
std::stack< vec4 > bg_accum_color_stack
stack of background accumulation colors
Definition context.h:707

cgv::render::context::get_model_point
vec3 get_model_point(int x_window, int y_window, double z_window) const
compute model space 3D point from the given opengl pixel location (window location)
Definition context.h:1429

cgv::render::context::default_material
cgv::media::illum::surface_material default_material
store a default material
Definition context.h:761

cgv::render::context::sRGB_framebuffer_enabled
bool sRGB_framebuffer_enabled()
check whether sRGB framebuffer is enabled
Definition context.h:1086

cgv::render::context::get_max_window_transformation_array_size
virtual unsigned get_max_window_transformation_array_size() const =0
query the maximum number of supported window transformations, which is at least 1

cgv::render::context::x_offset
int x_offset
offset in x and y direction where text starts
Definition context.h:792

cgv::render::context::attach_depth_buffer
virtual void attach_depth_buffer(bool attach=true)=0
attach or detach (attach=false) depth buffer to the current frame buffer if not present

cgv::render::context::light_sources
std::map< void *, std::pair< cgv::media::illum::light_source, light_source_status > > light_sources
map handle to light source and light source status information
Definition context.h:751

cgv::render::context::window_transformation_stack
std::stack< std::vector< window_transformation > > window_transformation_stack
keep stack of window transformations
Definition context.h:721

cgv::render::context::cursor_x
int cursor_x
current cursor location for textual output
Definition context.h:782

cgv::render::context::make_current
virtual bool make_current() const =0
make the current context current if possible

cgv::render::context::draw_in_compatibility_mode
bool draw_in_compatibility_mode
whether to do all drawing in compatibility mode, only possible if support_compatibility_mode is true,...
Definition context.h:688

cgv::render::context::sRGB_framebuffer
bool sRGB_framebuffer
whether to use opengl option to support sRGB framebuffer
Definition context.h:696

cgv::render::context::enumerate_program_attributes
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
get list of program attributes

cgv::render::context::get_modelview_matrix
virtual dmat4 get_modelview_matrix() const =0
return homogeneous 4x4 viewing matrix, which transforms from world to eye space

cgv::render::context::frame_buffer_stack
std::stack< frame_buffer_base * > frame_buffer_stack
stack of currently enabled frame buffers
Definition context.h:723

cgv::render::context::pop_pixel_coords
virtual void pop_pixel_coords()=0
pop previously pushed transformation matrices from modelview and projection stacks

cgv::render::context::at_line_begin
bool at_line_begin
store whether we are at the beginning of the line
Definition context.h:796

cgv::render::context::enable_material
virtual void enable_material(textured_material &mat)=0
enable a material with textures

cgv::render::context::auto_set_view_in_current_shader_program
bool auto_set_view_in_current_shader_program
whether to automatically set viewing matrixes in current shader program, defaults to true
Definition context.h:678

cgv::render::context::debug_render_passes
bool debug_render_passes
whether to debug render passes
Definition context.h:690

cgv::render::context::enabled_light_source_handles
std::vector< void * > enabled_light_source_handles
keep track of enabled light source handles
Definition context.h:747

cgv::render::context::attach_accumulation_buffer
virtual void attach_accumulation_buffer(bool attach=true)=0
attach or detach (attach=false) accumulation buffer to the current frame buffer if not present

cgv::render::context::attach_multi_sample_buffer
virtual void attach_multi_sample_buffer(bool attach=true)=0
attach or detach (attach=false) multi sample buffer to the current frame buffer if not present

cgv::render::context::ref_surface_shader_program
virtual shader_program & ref_surface_shader_program(bool texture_support=false)=0
return a reference to the default shader program used to render surfaces

cgv::render::context::post_redraw
virtual void post_redraw()=0
the context will be redrawn when the system is idle again

cgv::render::context::get_debug_render_passes
bool get_debug_render_passes() const
check whether render passes are debugged
Definition context.h:919

cgv::render::context::current_material_ptr
const cgv::media::illum::surface_material * current_material_ptr
store pointer to current material
Definition context.h:763

cgv::render::context::current_font_face
cgv::media::font::font_face_ptr current_font_face
store current font
Definition context.h:788

cgv::render::context::out_stream
cgv::signal::callback_stream out_stream
use a callback stream to write text to the opengl context
Definition context.h:784

cgv::render::context::bg_color_stack
std::stack< vec4 > bg_color_stack
stack of background colors
Definition context.h:701

cgv::render::context::blend_state_stack
std::stack< BlendState > blend_state_stack
stack of blend states
Definition context.h:714

cgv::render::context::auto_set_gamma_in_current_shader_program
bool auto_set_gamma_in_current_shader_program
whether to automatically set gamma in current shader program, defaults to true
Definition context.h:684

cgv::render::frame_buffer_base
base interface for framebuffer
Definition context.h:471

cgv::render::frame_buffer
this class encapsulate frame buffers that live on the GPU and can be used as destination for the rend...
Definition frame_buffer.h:17

cgv::render::render_buffer_base
base interface for a render_buffer
Definition context.h:324

cgv::render::render_buffer
this class encapsulate render buffers that live on the GPU which must support frame buffer objects fo...
Definition render_buffer.h:16

cgv::render::render_component
base interface for all render components
Definition context.h:301

cgv::render::render_component::put_id
void put_id(T &id) const
cast the refence to rendering api specific representation of component id to the specified type
Definition context.h:319

cgv::render::render_component::ctx_ptr
const context * ctx_ptr
keep pointer to my context
Definition context.h:307

cgv::render::render_component::last_error
std::string last_error
a string that contains the last error
Definition context.h:309

cgv::render::shader_code
a shader code object holds a code fragment of a geometry vertex or fragment shader and can be added t...
Definition shader_code.h:58

cgv::render::shader_program_base
base interface for shader programs
Definition context.h:355

cgv::render::shader_program
a shader program combines several shader code fragments to a complete definition of the shading pipel...
Definition shader_program.h:28

cgv::render::texture_base
base interface for a texture
Definition context.h:332

cgv::render::texture
the texture class encapsulates all functionality independent of the rendering api.
Definition texture.h:15

cgv::render::textured_material
class that extends obj_material with the management of textures
Definition textured_material.h:13

cgv::render::vertex_buffer_base
base interface for a vertex buffer
Definition context.h:450

cgv::render::vertex_buffer_base::type
VertexBufferType type
buffer type defaults to VBT_VERTICES
Definition context.h:453

cgv::render::vertex_buffer_base::usage
VertexBufferUsage usage
usage defaults to VBU_STATIC_DRAW
Definition context.h:455

cgv::render::vertex_buffer
a vertex buffer is an unstructured memory block on the GPU.
Definition vertex_buffer.h:13

cgv::render::view
defines a symmetric view with the following quantities:
Definition view.h:22

cgv::signal::callback_stream
connect to the write signal of the callback stream in order to process all text written to the stream
Definition callback_stream.h:48

cgv::data::ComponentFormat
ComponentFormat
define standard formats, which should be used to avoid wrong assignment of component names
Definition component_format.h:16

cgv::render::RenderAPI
RenderAPI
enumeration of rendering APIs which can be queried from the context
Definition context.h:70

cgv::render::CullingMode
CullingMode
different culling modes
Definition context.h:143

cgv::render::render_config_ptr
cgv::data::ref_ptr< render_config > render_config_ptr
type of ref counted pointer to render configuration
Definition context.h:605

cgv::render::context_config_ptr
cgv::data::ref_ptr< context_config > context_config_ptr
type of ref counted pointer to context creation configuration
Definition context.h:571

cgv::render::register_context_factory
void register_context_factory(context_creation_function_type fp)
registration context creation functions
Definition context.cxx:2430

cgv::render::BlendFunction
BlendFunction
different blend functions
Definition context.h:150

cgv::render::TextAlignment
TextAlignment
different text alignments
Definition context.h:273

cgv::render::TA_TOP
@ TA_TOP
center of top edge of text bounds
Definition context.h:277

cgv::render::TA_BOTTOM_RIGHT
@ TA_BOTTOM_RIGHT
bottom right corner of text bounds
Definition context.h:282

cgv::render::TA_BOTTOM
@ TA_BOTTOM
center of bottom edge of text bounds
Definition context.h:278

cgv::render::TA_NONE
@ TA_NONE
no alignment
Definition context.h:274

cgv::render::TA_RIGHT
@ TA_RIGHT
center of right edge of text bounds
Definition context.h:276

cgv::render::TA_BOTTOM_LEFT
@ TA_BOTTOM_LEFT
bottom left corner of text bounds
Definition context.h:281

cgv::render::TA_TOP_LEFT
@ TA_TOP_LEFT
top left corner of text bounds
Definition context.h:279

cgv::render::TA_LEFT
@ TA_LEFT
center of left edge of text bounds
Definition context.h:275

cgv::render::TA_TOP_RIGHT
@ TA_TOP_RIGHT
top right corner of text bounds
Definition context.h:280

cgv::render::AccessType
AccessType
different access types
Definition context.h:266

cgv::render::get_render_pass_name
std::string get_render_pass_name(RenderPass rp)
convert render pass type into string
Definition context.cxx:728

cgv::render::TextureFilter
TextureFilter
different texture filter
Definition context.h:189

cgv::render::get_render_config
render_config_ptr get_render_config()
return a pointer to the current shader configuration
Definition context.cxx:122

cgv::render::TextureWrap
TextureWrap
different texture wrap modes
Definition context.h:173

cgv::render::FrameBufferType
FrameBufferType
different frame buffer types which can be combined together with or
Definition context.h:488

cgv::render::MaterialSide
MaterialSide
different sides of a material
Definition context.h:128

cgv::render::TextureSampling
TextureSampling
different sampling strategies for rendering to textures that steer the computation of the tex_coord i...
Definition context.h:247

cgv::render::TS_VERTEX
@ TS_VERTEX
tex_coord ranges from [0,0,0] to [1,1,1]
Definition context.h:249

cgv::render::TS_CELL
@ TS_CELL
for texture resulution N x M x L the tex_coord ranges from [1/2N, 1/2M, 1/2L] to [1-1/2N,...
Definition context.h:248

cgv::render::ElementType
ElementType
different compond types for data elements
Definition context.h:39

cgv::render::create_context
context * create_context(RenderAPI api, unsigned int w, unsigned int h, const std::string &title, bool show)
construct a context of the given size.
Definition context.cxx:2443

cgv::render::VertexBufferUsage
VertexBufferUsage
Provides vertex buffer usage hints as defined in OpenGL.
Definition context.h:427

cgv::render::VBU_STATIC_COPY
@ VBU_STATIC_COPY
Modified once and used many times; Modified by reading data from the GL, and used as the source for G...
Definition context.h:438

cgv::render::VBU_STREAM_COPY
@ VBU_STREAM_COPY
Modified once and used at most a few times; Modified by reading data from the GL, and used as the sou...
Definition context.h:432

cgv::render::VBU_DYNAMIC_DRAW
@ VBU_DYNAMIC_DRAW
Modified repeatedly and used many times; Modified by the application, and used as the source for GL d...
Definition context.h:440

cgv::render::VBU_STREAM_READ
@ VBU_STREAM_READ
Modified once and used at most a few times; Modified by reading data from the GL, and used to return ...
Definition context.h:430

cgv::render::VBU_DYNAMIC_COPY
@ VBU_DYNAMIC_COPY
Modified repeatedly and used many times; Modified by reading data from the GL, and used as the source...
Definition context.h:444

cgv::render::VBU_STATIC_READ
@ VBU_STATIC_READ
Modified once and used many times; Modified by reading data from the GL, and used to return that data...
Definition context.h:436

cgv::render::VBU_STATIC_DRAW
@ VBU_STATIC_DRAW
Modified once and used many times; Modified by the application, and used as the source for GL drawing...
Definition context.h:434

cgv::render::VBU_DYNAMIC_READ
@ VBU_DYNAMIC_READ
Modified repeatedly and used many times; Modified by reading data from the GL, and used to return tha...
Definition context.h:442

cgv::render::VBU_STREAM_DRAW
@ VBU_STREAM_DRAW
Modified once and used at most a few times; Modified by the application, and used as the source for G...
Definition context.h:428

cgv::render::TextureCubeSides
TextureCubeSides
the six different sides of a cube
Definition context.h:215

cgv::render::IlluminationMode
IlluminationMode
different illumination modes
Definition context.h:136

cgv::render::ContextIntegerConstant
ContextIntegerConstant
integer constants that can be queried from context
Definition context.h:508

cgv::render::ShaderType
ShaderType
different shader types
Definition context.h:485

cgv::render::PrimitiveType
PrimitiveType
different primitive types
Definition context.h:225

cgv::render::VertexBufferType
VertexBufferType
Provides vertex buffer types to allow implicit binding.
Definition context.h:414

cgv::render::VBT_VERTICES
@ VBT_VERTICES
The buffer contains vertices and will be bound to GL_ARRAY_BUFFER.
Definition context.h:416

cgv::render::VBT_TEXTURE
@ VBT_TEXTURE
The buffer contains texture data and will be bound to GL_TEXTURE_BUFFER.
Definition context.h:418

cgv::render::VBT_UNDEF
@ VBT_UNDEF
The buffer has no type.
Definition context.h:415

cgv::render::VBT_INDICES
@ VBT_INDICES
The buffer contains indices and will be bound to GL_ELEMENT_ARRAY_BUFFER.
Definition context.h:417

cgv::render::VBT_ATOMIC_COUNTER
@ VBT_ATOMIC_COUNTER
The buffer contains atomic counter and will be bound to GL_ATOMIC_COUNTER_BUFFER.
Definition context.h:422

cgv::render::VBT_STORAGE
@ VBT_STORAGE
The buffer contains arbitrary data and will be bound to GL_SHADER_STORAGE_BUFFER.
Definition context.h:421

cgv::render::VBT_UNIFORM
@ VBT_UNIFORM
The buffer contains uniforms and will be bound to GL_UNIFORM_BUFFER.
Definition context.h:419

cgv::render::VBT_INDIRECT
@ VBT_INDIRECT
The buffer contains indirect draw commands and will be bound to GL_DRAW_INDIRECT_BUFFER.
Definition context.h:423

cgv::render::VBT_FEEDBACK
@ VBT_FEEDBACK
The buffer is used for transform&feedback and will be bound to GL_TRANSFORM_FEEDBACK_BUFFER.
Definition context.h:420

cgv::render::BufferTypeBits
BufferTypeBits
Bits for the selection of different buffer types.
Definition context.h:461

cgv::render::BTB_COLOR_BIT
@ BTB_COLOR_BIT
color buffer type
Definition context.h:462

cgv::render::BTB_STENCIL_BIT
@ BTB_STENCIL_BIT
stencil buffer type
Definition context.h:465

cgv::render::BTB_ALL_BITS
@ BTB_ALL_BITS
all buffer types
Definition context.h:466

cgv::render::BTB_COLOR_AND_DEPTH_BITS
@ BTB_COLOR_AND_DEPTH_BITS
color and depth buffer types
Definition context.h:464

cgv::render::BTB_DEPTH_BIT
@ BTB_DEPTH_BIT
depth buffer type
Definition context.h:463

cgv::render::RenderPass
RenderPass
Enumeration of different render passes, which can be queried from the context and used to specify a n...
Definition context.h:77

cgv::render::RP_SHADOW_VOLUME
@ RP_SHADOW_VOLUME
construction of shadow map
Definition context.h:82

cgv::render::RP_STEREO
@ RP_STEREO
rendering of second eye
Definition context.h:80

cgv::render::RP_USER_DEFINED
@ RP_USER_DEFINED
user defined renderpass
Definition context.h:86

cgv::render::RP_OPAQUE_SURFACES
@ RP_OPAQUE_SURFACES
opaque surface rendering using z-Buffer
Definition context.h:83

cgv::render::RP_NONE
@ RP_NONE
no renderpass
Definition context.h:78

cgv::render::RP_MAIN
@ RP_MAIN
the main rendering pass triggered by the redraw event
Definition context.h:79

cgv::render::RP_TRANSPARENT_SURFACES
@ RP_TRANSPARENT_SURFACES
transparent surface rendering using depth peeling
Definition context.h:84

cgv::render::RP_PICK
@ RP_PICK
in picking pass a small rectangle around the mouse is rendered
Definition context.h:85

cgv::render::RP_SHADOW_MAP
@ RP_SHADOW_MAP
construction of shadow map
Definition context.h:81

cgv::render::TextureType
TextureType
different texture types
Definition context.h:201

cgv::render::RenderPassFlags
RenderPassFlags
available flags that can be queried from the context and set for a new render pass
Definition context.h:93

cgv::render::RPF_CLEAR_ACCUM
@ RPF_CLEAR_ACCUM
whether to clear the accumulation buffer
Definition context.h:108

cgv::render::RPF_SET_MODELVIEW
@ RPF_SET_MODELVIEW
whether to set default modelview matrix
Definition context.h:96

cgv::render::RPF_DRAWABLES_FINISH_FRAME
@ RPF_DRAWABLES_FINISH_FRAME
whether to call finish frame method of drawables
Definition context.h:118

cgv::render::RPF_SET_MATERIAL
@ RPF_SET_MATERIAL
whether to define default material
Definition context.h:100

cgv::render::RPF_SET_CLEAR_DEPTH
@ RPF_SET_CLEAR_DEPTH
whether to set the clear color
Definition context.h:114

cgv::render::RPF_ALL
@ RPF_ALL
all flags set, defines default render pass
Definition context.h:122

cgv::render::RPF_SET_LIGHTS
@ RPF_SET_LIGHTS
whether to define default lights
Definition context.h:99

cgv::render::RPF_CLEAR_COLOR
@ RPF_CLEAR_COLOR
whether to clear the color buffer
Definition context.h:105

cgv::render::RPF_DRAWABLES_DRAW
@ RPF_DRAWABLES_DRAW
whether to call draw and finish_draw methods of drawables
Definition context.h:117

cgv::render::RPF_CLEAR_STENCIL
@ RPF_CLEAR_STENCIL
whether to clear the depth buffer
Definition context.h:107

cgv::render::RPF_SET_MODELVIEW_PROJECTION
@ RPF_SET_MODELVIEW_PROJECTION
whether to set default modelview and projection matrix
Definition context.h:97

cgv::render::RPF_SET_CLEAR_STENCIL
@ RPF_SET_CLEAR_STENCIL
whether to set the clear color
Definition context.h:115

cgv::render::RPF_ENABLE_MATERIAL
@ RPF_ENABLE_MATERIAL
whether to enable material
Definition context.h:102

cgv::render::RPF_DRAWABLES_INIT_FRAME
@ RPF_DRAWABLES_INIT_FRAME
whether to call the init_frame method of the drawables
Definition context.h:111

cgv::render::RPF_DRAWABLES_AFTER_FINISH
@ RPF_DRAWABLES_AFTER_FINISH
whether to call after finish method of drawables
Definition context.h:120

cgv::render::RPF_DEFAULT
@ RPF_DEFAULT
all flags set, defines default render pass
Definition context.h:123

cgv::render::RPF_NONE
@ RPF_NONE
no frame initialization is performed
Definition context.h:94

cgv::render::RPF_HANDLE_SCREEN_SHOT
@ RPF_HANDLE_SCREEN_SHOT
whether to perform a screen shot if this was scheduled
Definition context.h:121

cgv::render::RPF_CLEAR_DEPTH
@ RPF_CLEAR_DEPTH
whether to clear the depth buffer
Definition context.h:106

cgv::render::RPF_SET_STATE_FLAGS
@ RPF_SET_STATE_FLAGS
whether to set depth buffer and culling flags
Definition context.h:112

cgv::render::RPF_CLEAR_ALL
@ RPF_CLEAR_ALL
whether to clear all buffers
Definition context.h:109

cgv::render::RPF_DRAW_TEXTUAL_INFO
@ RPF_DRAW_TEXTUAL_INFO
whether to draw textual information
Definition context.h:119

cgv::render::RPF_SET_PROJECTION
@ RPF_SET_PROJECTION
whether to set default projection matrix
Definition context.h:95

cgv::render::RPF_SET_LIGHTING
@ RPF_SET_LIGHTING
whether to define and enable default lighting
Definition context.h:103

cgv::render::RPF_SET_CLEAR_ACCUM
@ RPF_SET_CLEAR_ACCUM
whether to set the accumulation buffer clear color
Definition context.h:116

cgv::render::RPF_SET_CLEAR_COLOR
@ RPF_SET_CLEAR_COLOR
whether to set the clear color
Definition context.h:113

cgv::render::RPF_SET_LIGHTS_ON
@ RPF_SET_LIGHTS_ON
whether to turn on default lights
Definition context.h:101

cgv::render::CompareFunction
CompareFunction
different comparison functions used for depth testing or texture comparisons
Definition context.h:254

cgv::render::GPUVendorID
GPUVendorID
IDs for GPU vendors.
Definition context.h:31

cgv::type::info::TypeId
TypeId
ids for the different types and type constructs
Definition type_id.h:12

cgv::type::info::TI_UINT8
@ TI_UINT8
signed integer stored in 64 bits
Definition type_id.h:23

cgv
the cgv namespace
Definition print.h:11

cgv::dmat4
cgv::math::fmat< double, 4, 4 > dmat4
declare type of 4x4 matrices
Definition fmat.h:369

cgv::dmatn
cgv::math::mat< double > dmatn
declare type of matrices of varying dimensions
Definition mat.h:1383

cgv::render::context::BlendState
Represents a blend state used to configure fragment blending.
Definition context.h:645

cgv::render::context::BufferMask
Represents a buffer mask used to mask depth and color buffer outputs.
Definition context.h:660

cgv::render::context::DepthTestState
Represents a depth test state used to configure depth testing.
Definition context.h:637

cgv::render::context::light_source_status
status information of light sources
Definition context.h:740

cgv::render::context::render_info
information necessary for a rendering pass
Definition context.h:768

cgv::render::context_config
configuration object used to define context parameters that need to be set already at creation time
Definition context.h:525

cgv::render::context_config::multi_sample_buffer
bool multi_sample_buffer
default: false
Definition context.h:541

cgv::render::context_config::stencil_buffer
bool stencil_buffer
default: false
Definition context.h:537

cgv::render::context_config::version_minor
int version_minor
default: -1 ... minor version of maximum supported OpenGL version
Definition context.h:554

cgv::render::context_config::depth_bits
int depth_bits
default: -1
Definition context.h:543

cgv::render::context_config::double_buffer
bool double_buffer
default: true
Definition context.h:531

cgv::render::context_config::version_major
int version_major
default: -1 ... major version of maximum supported OpenGL version
Definition context.h:552

cgv::render::context_config::debug
bool debug
default: false in release and true in debug version
Definition context.h:558

cgv::render::context_config::forward_compatible
bool forward_compatible
default: false
Definition context.h:556

cgv::render::context_config::context_creation_attrib_list
std::vector< int > context_creation_attrib_list
provide integer vector to store context creation attribute list
Definition context.h:567

cgv::render::context_config::stereo_buffer
bool stereo_buffer
default: false
Definition context.h:535

cgv::render::context_config::alpha_buffer
bool alpha_buffer
default: false
Definition context.h:533

cgv::render::context_config::core_profile
bool core_profile
default: true
Definition context.h:560

cgv::render::context_config::stencil_bits
int stencil_bits
default: -1
Definition context.h:545

cgv::render::context_config::nr_multi_samples
int nr_multi_samples
default: -1
Definition context.h:549

cgv::render::context_config::accumulation_buffer
bool accumulation_buffer
default: false
Definition context.h:539

cgv::render::context_config::accumulation_bits
int accumulation_bits
default: -1
Definition context.h:547

cgv::render::context_config::depth_buffer
bool depth_buffer
default: true
Definition context.h:529

cgv::render::context_factory_registration
Definition context.h:1489

cgv::render::render_config
configuration object used to define render view creation parameters including error handling configur...
Definition context.h:575

cgv::render::render_config::window_width
int window_width
default: 640
Definition context.h:581

cgv::render::render_config::dialog_on_error
bool dialog_on_error
default: true (only in case a gui_driver, which supports this, is loaded)
Definition context.h:591

cgv::render::render_config::fullscreen_monitor
int fullscreen_monitor
default: -1 ... no fullscreen
Definition context.h:579

cgv::render::render_config::window_height
int window_height
default: 480
Definition context.h:583

cgv::render::render_config::abort_on_error
bool abort_on_error
default: false
Definition context.h:589

cgv::render::render_config::show_error_on_console
bool show_error_on_console
default: true
Definition context.h:593

cgv::render::type_descriptor
compact type description of data that can be sent to the context; convertible to int
Definition context.h:47

cgv::render::type_descriptor::type_descriptor
type_descriptor(const type_descriptor &td, bool _is_array)
construct descriptor for an array
Definition context.h:64

cgv::render::type_descriptor::type_descriptor
type_descriptor(cgv::type::info::TypeId _coordinate_type, bool _normalize=false)
construct descriptor for values
Definition context.h:58

cgv::render::type_descriptor::type_descriptor
type_descriptor(cgv::type::info::TypeId _coordinate_type, unsigned _nr_rows, unsigned _nr_cols, bool _is_row_major, bool _normalize=false)
construct descriptor for matrices
Definition context.h:62

cgv::render::type_descriptor::type_descriptor
type_descriptor(cgv::type::info::TypeId _coordinate_type, unsigned _nr_entries, bool _normalize=false)
construct descriptor for vectors
Definition context.h:60

cgv::render::type_descriptor::type_descriptor
type_descriptor(int td=0)
construct from int
Definition context.h:56

cgv::render::window_transformation
parameters necessary to define window transformation
Definition context.h:612

cgv::render::window_transformation::depth_range
dvec2 depth_range
range of depth values [min_depth, max_depth]
Definition context.h:616

cgv::render::window_transformation::viewport
ivec4 viewport
viewport parameters [x0,y0,width,height]
Definition context.h:614