Graph editor: Add channel option to make it persistent on display
[blender.git] / source / blender / editors / include / BIF_glutil.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation 2002-2008
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file BIF_glutil.h
27  *  \ingroup editorui
28  */
29
30 #ifndef __BIF_GLUTIL_H__
31 #define __BIF_GLUTIL_H__
32
33 struct rcti;
34 struct rctf;
35
36 struct ImBuf;
37 struct bContext;
38 struct ColorManagedViewSettings;
39 struct ColorManagedDisplaySettings;
40
41 void fdrawbezier(float vec[4][3]);
42 void fdrawline(float x1, float y1, float x2, float y2);
43 void fdrawbox(float x1, float y1, float x2, float y2);
44 void sdrawline(int x1, int y1, int x2, int y2);
45 #if 0
46 void sdrawtri(int x1, int y1, int x2, int y2);
47 void sdrawtrifill(int x1, int y1, int x2, int y2);
48 #endif
49 void sdrawbox(int x1, int y1, int x2, int y2);
50
51 void sdrawXORline(int x0, int y0, int x1, int y1);
52 void sdrawXORline4(int nr, int x0, int y0, int x1, int y1);
53
54 void fdrawXORellipse(float xofs, float yofs, float hw, float hh);
55 void fdrawXORcirc(float xofs, float yofs, float rad);
56
57 void fdrawcheckerboard(float x1, float y1, float x2, float y2);
58
59 /* OpenGL stipple defines */
60 extern const unsigned char stipple_halftone[128];
61 extern const unsigned char stipple_quarttone[128];
62 extern const unsigned char stipple_diag_stripes_pos[128];
63 extern const unsigned char stipple_diag_stripes_neg[128];
64 extern const unsigned char stipple_checker_8px[128];
65
66 /**
67  * Draw a lined (non-looping) arc with the given
68  * \a radius, starting at angle \a start and arcing
69  * through \a angle. The arc is centered at the origin
70  * and drawn in the XY plane.
71  *
72  * \param start The initial angle (in radians).
73  * \param angle The length of the arc (in radians).
74  * \param radius The arc radius.
75  * \param nsegments The number of segments to use in drawing the arc.
76  */
77 void glutil_draw_lined_arc(float start, float angle, float radius, int nsegments);
78
79 /**
80  * Draw a filled arc with the given \a radius,
81  * starting at angle \a start and arcing through
82  * \a angle. The arc is centered at the origin
83  * and drawn in the XY plane.
84  *
85  * \param start The initial angle (in radians).
86  * \param angle The length of the arc (in radians).
87  * \param radius The arc radius.
88  * \param nsegments The number of segments to use in drawing the arc.
89  */
90 void glutil_draw_filled_arc(float start, float angle, float radius, int nsegments);
91
92 /**
93  * Returns a float value as obtained by glGetFloatv.
94  * The param must cause only one value to be gotten from GL.
95  */
96 float glaGetOneFloat(int param);
97 int glaGetOneInt(int param);
98
99 /**
100  * Functions like glRasterPos2i, except ensures that the resulting
101  * raster position is valid. \a known_good_x and \a known_good_y
102  * should be coordinates of a point known to be within the current
103  * view frustum.
104  * \attention This routine should be used when the distance of \a x
105  * and \a y away from the known good point is small (ie. for small icons
106  * and for bitmap characters), when drawing large+zoomed images it is
107  * possible for overflow to occur, the glaDrawPixelsSafe routine should
108  * be used instead.
109  */
110 void glaRasterPosSafe2f(float x, float y, float known_good_x, float known_good_y);
111
112 /**
113  * Functions like a limited glDrawPixels, except ensures that
114  * the image is displayed onscreen even if the \a x and \a y
115  * coordinates for would be clipped. The routine respects the
116  * glPixelZoom values, pixel unpacking parameters are _not_
117  * respected.
118  *
119  * \attention This routine makes many assumptions: the rect data
120  * is expected to be in RGBA unsigned byte format, the coordinate
121  * (GLA_PIXEL_OFS, GLA_PIXEL_OFS) is assumed to be within the view frustum,
122  * and the modelview and projection matrices are assumed to define a
123  * 1-to-1 mapping to screen space.
124  * \attention Furthermore, in the case of zoomed or unpixel aligned
125  * images extending outside the view frustum, but still within the
126  * window, some portion of the image may be visible left and/or
127  * below of the given \a x and \a y coordinates. It is recommended
128  * to use the glScissor functionality if images are to be drawn
129  * with an inset view matrix.
130  */
131 void glaDrawPixelsSafe(float x, float y, int img_w, int img_h, int row_w, int format, int type, void *rect);
132
133 /**
134  * glaDrawPixelsTex - Functions like a limited glDrawPixels, but actually draws the
135  * image using textures, which can be tremendously faster on low-end
136  * cards, and also avoids problems with the raster position being
137  * clipped when offscreen. The routine respects the glPixelZoom values,
138  * pixel unpacking parameters are _not_ respected.
139  *
140  * \attention This routine makes many assumptions: the rect data
141  * is expected to be in RGBA byte or float format, and the
142  * modelview and projection matrices are assumed to define a
143  * 1-to-1 mapping to screen space.
144  */
145
146 void glaDrawPixelsTex(float x, float y, int img_w, int img_h, int format, int type, int zoomfilter, void *rect);
147 void glaDrawPixelsTex_clipping(float x, float y, int img_w, int img_h, int format, int type, int zoomfilter, void *rect,
148                                float clip_min_x, float clip_min_y, float clip_max_x, float clip_max_y);
149
150 /**
151  * glaDrawPixelsAuto - Switches between texture or pixel drawing using UserDef.
152  * only RGBA
153  * needs glaDefine2DArea to be set.
154  */
155 void glaDrawPixelsAuto(float x, float y, int img_w, int img_h, int format, int type, int zoomfilter, void *rect);
156 void glaDrawPixelsAuto_clipping(float x, float y, int img_w, int img_h, int format, int type, int zoomfilter, void *rect,
157                                 float clip_min_x, float clip_min_y, float clip_max_x, float clip_max_y);
158
159
160 void glaDrawPixelsTexScaled(float x, float y, int img_w, int img_h, int format, int type, int zoomfilter, void *rect, float scaleX, float scaleY);
161 void glaDrawPixelsTexScaled_clipping(float x, float y, int img_w, int img_h, int format, int type, int zoomfilter, void *rect, float scaleX, float scaleY,
162                                      float clip_min_x, float clip_min_y, float clip_max_x, float clip_max_y);
163
164 /* 2D Drawing Assistance */
165
166 /** Define a 2D area (viewport, scissor, matrices) for OpenGL rendering.
167  *
168  * glaDefine2DArea and glaBegin2DDraw set up an OpenGL state appropriate
169  * for drawing using both vertex (Vertex, etc) and raster (RasterPos, Rect)
170  * commands. All coordinates should be at integer positions. There is little
171  * to no reason to use glVertex2f etc. functions during 2D rendering, and
172  * thus no reason to +-0.5 the coordinates or perform other silly
173  * tricks.
174  *
175  * \param screen_rect The screen rectangle to be defined for 2D drawing.
176  */
177 void glaDefine2DArea(struct rcti *screen_rect);
178
179 typedef struct gla2DDrawInfo gla2DDrawInfo;
180
181 /* UNUSED */
182 #if 0
183
184 gla2DDrawInfo  *glaBegin2DDraw(struct rcti *screen_rect, struct rctf *world_rect);
185 void gla2DDrawTranslatePt(gla2DDrawInfo *di, float wo_x, float wo_y, int *r_sc_x, int *r_sc_y);
186 void gla2DDrawTranslatePtv(gla2DDrawInfo *di, float world[2], int r_screen[2]);
187
188 void glaEnd2DDraw(gla2DDrawInfo *di);
189
190 /** Adjust the transformation mapping of a 2d area */
191 void gla2DGetMap(gla2DDrawInfo *di, struct rctf *rect);
192 void gla2DSetMap(gla2DDrawInfo *di, struct rctf *rect);
193 #endif
194
195 void set_inverted_drawing(int enable);
196 void setlinestyle(int nr);
197
198 /* own working polygon offset */
199 void bglPolygonOffset(float viewdist, float dist);
200
201 /* For caching opengl matrices (gluProject/gluUnProject) */
202 typedef struct bglMats {
203         double modelview[16];
204         double projection[16];
205         int viewport[4];
206 } bglMats;
207 void bgl_get_mats(bglMats *mats);
208
209 /* **** Color management helper functions for GLSL display/transform ***** */
210
211 /* Draw imbuf on a screen, preferably using GLSL display transform */
212 void glaDrawImBuf_glsl(struct ImBuf *ibuf, float x, float y, int zoomfilter,
213                        struct ColorManagedViewSettings *view_settings,
214                        struct ColorManagedDisplaySettings *display_settings);
215 void glaDrawImBuf_glsl_clipping(struct ImBuf *ibuf, float x, float y, int zoomfilter,
216                                 struct ColorManagedViewSettings *view_settings,
217                                 struct ColorManagedDisplaySettings *display_settings,
218                                 float clip_min_x, float clip_min_y,
219                                 float clip_max_x, float clip_max_y);
220
221
222 /* Draw imbuf on a screen, preferably using GLSL display transform */
223 void glaDrawImBuf_glsl_ctx(const struct bContext *C, struct ImBuf *ibuf, float x, float y, int zoomfilter);
224 void glaDrawImBuf_glsl_ctx_clipping(const struct bContext *C,
225                                     struct ImBuf *ibuf,
226                                     float x, float y,
227                                     int zoomfilter,
228                                     float clip_min_x, float clip_min_y,
229                                     float clip_max_x, float clip_max_y);
230
231 void glaDrawBorderCorners(const struct rcti *border, float zoomx, float zoomy);
232
233 #endif /* __BIF_GLUTIL_H__ */
234