Color management: add "Color Unpremultiply" option for images and render settings.
[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 void fdrawbezier(float vec[4][3]);
37 void fdrawline(float x1, float y1, float x2, float y2);
38 void fdrawbox(float x1, float y1, float x2, float y2);
39 void sdrawline(short x1, short y1, short x2, short y2);
40 void sdrawtri(short x1, short y1, short x2, short y2);
41 void sdrawtrifill(short x1, short y1, short x2, short y2);
42 void sdrawbox(short x1, short y1, short x2, short y2);
43
44 void sdrawXORline(int x0, int y0, int x1, int y1);
45 void sdrawXORline4(int nr, int x0, int y0, int x1, int y1);
46
47 void fdrawXORellipse(float xofs, float yofs, float hw, float hh);
48 void fdrawXORcirc(float xofs, float yofs, float rad);
49
50 /* glStipple defines */
51 extern unsigned char stipple_halftone[128];
52 extern unsigned char stipple_quarttone[128];
53 extern unsigned char stipple_diag_stripes_pos[128];
54 extern unsigned char stipple_diag_stripes_neg[128];
55
56         /**
57          * Draw a lined (non-looping) arc with the given
58          * @a radius, starting at angle @a start and arcing 
59          * through @a angle. The arc is centered at the origin 
60          * and drawn in the XY plane.
61          * 
62          * @param start The initial angle (in radians).
63          * @param angle The length of the arc (in radians).
64          * @param radius The arc radius.
65          * @param nsegments The number of segments to use in drawing the arc.
66          */
67 void glutil_draw_lined_arc      (float start, float angle, float radius, int nsegments);
68
69         /**
70          * Draw a filled arc with the given @a radius, 
71          * starting at angle @a start and arcing through 
72          * @a angle. The arc is centered at the origin 
73          * and drawn in the XY plane.
74          * 
75          * @param start The initial angle (in radians).
76          * @param angle The length of the arc (in radians).
77          * @param radius The arc radius.
78          * @param nsegments The number of segments to use in drawing the arc.
79          */
80 void glutil_draw_filled_arc     (float start, float angle, float radius, int nsegments);
81
82         /**
83          * Routines an integer value as obtained by glGetIntegerv.
84          * The param must cause only one value to be gotten from GL.
85          */
86 int glaGetOneInteger            (int param);
87
88         /**
89          * Routines a float value as obtained by glGetIntegerv.
90          * The param must cause only one value to be gotten from GL.
91          */
92 float glaGetOneFloat            (int param);
93
94         /**
95          * Functions like glRasterPos2i, except ensures that the resulting
96          * raster position is valid. @a known_good_x and @a known_good_y
97          * should be coordinates of a point known to be within the current
98          * view frustum.
99          * @attention This routine should be used when the distance of @a x 
100          * and @y away from the known good point is small (ie. for small icons
101          * and for bitmap characters), when drawing large+zoomed images it is
102          * possible for overflow to occur, the glaDrawPixelsSafe routine should
103          * be used instead.
104          */
105 void glaRasterPosSafe2f         (float x, float y, float known_good_x, float known_good_y);
106
107         /**
108          * Functions like a limited glDrawPixels, except ensures that 
109          * the image is displayed onscreen even if the @a x and @a y 
110          * coordinates for would be clipped. The routine respects the
111          * glPixelZoom values, pixel unpacking parameters are _not_ 
112          * respected.
113
114          * @attention This routine makes many assumptions: the rect data
115          * is expected to be in RGBA unsigned byte format, the coordinate
116          * (0.375, 0.375) is assumed to be within the view frustum, and the 
117          * modelview and projection matrices are assumed to define a 
118          * 1-to-1 mapping to screen space.
119          * @attention Furthmore, in the case of zoomed or unpixel aligned
120          * images extending outside the view frustum, but still within the 
121          * window, some portion of the image may be visible left and/or
122          * below of the given @a x and @a y coordinates. It is recommended
123          * to use the glScissor functionality if images are to be drawn
124          * with an inset view matrix.
125          */
126 void glaDrawPixelsSafe          (float x, float y, int img_w, int img_h, int row_w, int format, int type, void *rect);
127
128         /**
129          * Functions like a limited glDrawPixels, but actually draws the
130          * image using textures, which can be tremendously faster on low-end
131          * cards, and also avoids problems with the raster position being
132          * clipped when offscreen. The routine respects the glPixelZoom values, 
133          * pixel unpacking parameters are _not_ respected.
134
135          * @attention This routine makes many assumptions: the rect data
136          * is expected to be in RGBA byte or float format, and the 
137          * modelview and projection matrices are assumed to define a 
138          * 1-to-1 mapping to screen space.
139          */
140
141 void glaDrawPixelsTex           (float x, float y, int img_w, int img_h, int format, void *rect);
142
143 void glaDrawPixelsTexScaled(float x, float y, int img_w, int img_h, int format, void *rect, float scaleX, float scaleY);
144
145         /* 2D Drawing Assistance */
146
147         /** Define a 2D area (viewport, scissor, matrices) for OpenGL rendering.
148          * This routine sets up an OpenGL state appropriate for drawing using
149          * both vertice (glVertex, etc) and raster (glRasterPos, glRect) commands.
150          * All coordinates should be at integer positions. There is little to
151          * no reason to use glVertex2f etc. functions during 2D rendering, and
152          * thus no reason to +-0.5 the coordinates or perform other silly
153          * tricks.
154          *
155          * @param screen_rect The screen rectangle to be defined for 2D drawing.
156          */
157 void glaDefine2DArea            (struct rcti *screen_rect);
158
159 typedef struct gla2DDrawInfo gla2DDrawInfo;
160
161         /** Save the current OpenGL state and initialize OpenGL for 2D
162          * rendering. glaEnd2DDraw should be called on the returned structure
163          * to free it and to return OpenGL to its previous state. The
164          * scissor rectangle is set to match the viewport.
165          *
166          * This routine sets up an OpenGL state appropriate for drawing using
167          * both vertice (glVertex, etc) and raster (glRasterPos, glRect) commands.
168          * All coordinates should be at integer positions. There is little to
169          * no reason to use glVertex2f etc. functions during 2D rendering, and
170          * thus no reason to +-0.5 the coordinates or perform other silly
171          * tricks.
172          *
173          * @param screen_rect The screen rectangle to be used for 2D drawing.
174          * @param world_rect The world rectangle that the 2D area represented
175          * by @a screen_rect is supposed to represent. If NULL it is assumed the
176          * world has a 1 to 1 mapping to the screen.
177          */
178 gla2DDrawInfo*  glaBegin2DDraw                  (struct rcti *screen_rect, struct rctf *world_rect);
179
180         /** Translate the (@a wo_x, @a wo_y) point from world coordinates into screen space. */
181 void                    gla2DDrawTranslatePt    (gla2DDrawInfo *di, float wo_x, float wo_y, int *sc_x_r, int *sc_y_r);
182
183         /** Translate the @a world point from world coordiantes into screen space. */
184 void                    gla2DDrawTranslatePtv   (gla2DDrawInfo *di, float world[2], int screen_r[2]);
185
186         /* Restores the previous OpenGL state and free's the auxilary
187          * gla data.
188          */
189 void                    glaEnd2DDraw                    (gla2DDrawInfo *di);
190
191         /** Adjust the transformation mapping of a 2d area */
192 void gla2DGetMap(gla2DDrawInfo *di, struct rctf *rect);
193 void gla2DSetMap(gla2DDrawInfo *di, struct rctf *rect);
194
195
196 /* use this for platform hacks. glPointSize is solved here */
197 void bglBegin(int mode);
198 void bglEnd(void);
199 int bglPointHack(void);
200 void bglVertex3fv(float *vec);
201 void bglVertex3f(float x, float y, float z);
202 void bglVertex2fv(float *vec);
203 /* intel gfx cards frontbuffer problem */
204 void bglFlush(void);
205 void set_inverted_drawing(int enable);
206 void setlinestyle(int nr);
207
208 /* own working polygon offset */
209 void bglPolygonOffset(float viewdist, float dist);
210
211 /* For caching opengl matrices (gluProject/gluUnProject) */
212 typedef struct bglMats {
213         double modelview[16];
214         double projection[16];
215         int viewport[4];
216 } bglMats;
217 void bgl_get_mats(bglMats *mats);
218
219 #endif /* BIF_GLUTIL_H */
220