graphic_context.h

Go to the documentation of this file.

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


#pragma once

#include "../api_display.h"
#include "../2D/color.h"
#include "../../Core/System/sharedptr.h"
#include "primitives_array.h"
#include "../../Core/Math/mat4.h"
#include "../../Core/IOData/virtual_directory.h"
#include "../../Core/Math/rect.h"
#include "../../Core/Signals/signal_v0.h"

class CL_Size;
class CL_BufferControl;
class CL_PolygonRasterizer;
class CL_Pen;
class CL_BlendMode;
class CL_Texture;
class CL_FrameBuffer;
class CL_PixelBuffer;
class CL_PixelBufferRef;
class CL_PrimitivesArray;
class CL_Font;
class CL_FontMetrics;
class CL_GraphicContextProvider;
class CL_GraphicContext_Impl;
class CL_ProgramObject;
class CL_ElementArrayBuffer;
class CL_Angle;
class CL_RenderBatcher;
class CL_FontProvider_Freetype;

enum CL_PrimitivesType
{
        cl_points,
        cl_line_strip,
        cl_line_loop,
        cl_lines,
        cl_triangle_strip,
        cl_triangle_fan,
        cl_triangles,
        cl_quad_strip,
        cl_quads,
        cl_polygon
};

enum CL_MapMode
{
        cl_map_2d_upper_left,
        cl_map_2d_lower_left,
        cl_user_projection
};

enum CL_StandardProgram
{
        cl_program_color_only,
        cl_program_single_texture,
        cl_program_sprite
};

class CL_API_DISPLAY CL_GraphicContext
{

public:
        CL_GraphicContext();

        CL_GraphicContext(CL_GraphicContextProvider *provider);

        ~CL_GraphicContext();

public:
        CL_Texture get_texture(int index);

        CL_BlendMode get_blend_mode();

        CL_BufferControl get_buffer_control();

        CL_PolygonRasterizer get_polygon_rasterizer();

        CL_Pen get_pen();

        int get_width() const;

        int get_height() const;

        CL_Size get_size() const;

        CL_Rect get_cliprect() const;

        const CL_Mat4f &get_modelview() const;


        CL_Size get_max_texture_size() const;

        CL_GraphicContextProvider *get_provider();

        const CL_GraphicContextProvider * const get_provider() const;

public:

        CL_GraphicContext create_worker_gc();

        CL_PixelBuffer get_pixeldata(const CL_Rect& rect = CL_Rect(0,0,0,0)) const;

        void set_frame_buffer(const CL_FrameBuffer &frame_buffer);

        void reset_frame_buffer();

        void set_texture(int unit_index, const CL_Texture &texture);

        void reset_texture(int unit_index);

        void set_program_object(CL_StandardProgram standard_program);

        void set_program_object(const CL_ProgramObject &program);

        void reset_program_object();

        void set_blend_mode(const CL_BlendMode &blend_mode);

        void reset_blend_mode();

        void set_buffer_control(const CL_BufferControl &buffer_control);

        void reset_buffer_control();

        void set_pen(const CL_Pen &pen);

        void reset_pen();

        void set_polygon_rasterizer(const CL_PolygonRasterizer &raster);

        void reset_polygon_rasterizer();

        void draw_primitives(CL_PrimitivesType type, int num_vertices, const CL_PrimitivesArray &array);

        void set_primitives_array(const CL_PrimitivesArray &array);

        void draw_primitives_array(CL_PrimitivesType type, int num_vertices);

        void draw_primitives_array(CL_PrimitivesType type, int offset, int num_vertices);

        void draw_primitives_elements(CL_PrimitivesType type, int count, unsigned int *indices);

        void draw_primitives_elements(CL_PrimitivesType type, int count, unsigned short *indices);

        void draw_primitives_elements(CL_PrimitivesType type, int count, unsigned char *indices);

        void draw_primitives_elements(CL_PrimitivesType type, int count, CL_ElementArrayBuffer &element_array, CL_VertexAttributeDataType indices_type, void *offset = 0);

        void reset_primitives_array();

        void draw_pixels(float x, float y, const CL_PixelBufferRef &pixel_buffer, const CL_Colorf &color = CL_Colorf::white);

        void draw_pixels(float x, float y, float zoom_x, float zoom_y, const CL_PixelBufferRef &pixel_buffer, const CL_Colorf &color = CL_Colorf::white);

        void clear(const CL_Colorf &color = CL_Colorf::black);

        void clear_stencil(int value = 0);

        void clear_depth(float value = 0);

        void set_cliprect(const CL_Rect &rect);


        void push_cliprect(const CL_Rect &rect);

        void push_cliprect();

        void pop_cliprect();

        void reset_cliprect();

        void set_map_mode(CL_MapMode mode);

        void set_viewport(const CL_Rectf &viewport);

        void set_projection(const CL_Mat4f &matrix);

        void set_modelview(const CL_Mat4f &matrix);

        void mult_modelview(const CL_Mat4f &matrix);

        void push_modelview();


        void set_translate(float x, float y, float z = 0.0);


        void mult_translate(float x, float y, float z = 0.0);


        void push_translate(float x, float y, float z = 0.0);

        void set_rotate(const CL_Angle &angle, float x = 0.0, float y = 0.0, float z = 1.0, bool normalize = true);

        void mult_rotate(const CL_Angle &angle, float x = 0.0, float y = 0.0, float z = 1.0, bool normalize = true);

        void push_rotate(const CL_Angle &angle, float x = 0.0, float y = 0.0, float z = 1.0);

        void set_scale(float x, float y, float z = 1.0);

        void mult_scale(float x, float y, float z = 1.0);

        void push_scale(float x, float y, float z = 1.0);

        void pop_modelview();

        void flush_batcher();

        void set_batcher(CL_RenderBatcher *batcher);

public:
        CL_Signal_v0 &sig_gc_destruction_imminent();

private:
        CL_SharedPtr<CL_GraphicContext_Impl> impl;

        friend class CL_PrimitivesArray;
        friend class CL_Sprite_Impl;
        friend class CL_Image;
        friend class CL_GlyphCache;
        friend class CL_Draw;
};

#ifndef cl_pixelcenter_constant
#define cl_pixelcenter_constant 0.375f
#endif

---