93ca90ce12f9152c83c9ae878544d61607e1b3e4
[blender.git] / source / blender / editors / include / BIF_glutil.h
1 /**
2  * @file BIF_glutil.h
3  * 
4  * OpenGL drawing utility functions.
5  * 
6  * $Id: BIF_glutil.h 10207 2007-03-06 03:39:15Z halley $
7  *
8  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version. The Blender
14  * Foundation also sells licenses for use in proprietary software under
15  * the Blender License.  See http://www.blender.org/BL/ for information
16  * about this.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  *
27  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
28  * All rights reserved.
29  *
30  * The Original Code is: all of this file.
31  *
32  * Contributor(s): none yet.
33  *
34  * ***** END GPL/BL DUAL LICENSE BLOCK *****
35  */
36
37 #ifndef BIF_GLUTIL_H
38 #define BIF_GLUTIL_H
39
40 struct rcti;
41 struct rctf;
42
43 void sdrawXORline(int x0, int y0, int x1, int y1);
44 void sdrawXORline4(int nr, int x0, int y0, int x1, int y1);
45
46 void fdrawXORellipse(float xofs, float yofs, float hw, float hh);
47 void fdrawXORcirc(float xofs, float yofs, float rad);
48
49         /**
50          * Draw an XOR'd line in the front buffer between
51          * the given points. 
52          *
53          * @attention This function also handles flushing the GL
54          * pipeline, which means it is inappropriate for drawing
55          * a large number of lines at once.
56          */
57 void glutil_draw_front_xor_line(int x0, int y0, int x1, int y1);
58
59         /**
60          * Draw a lined (non-looping) arc with the given
61          * @a radius, starting at angle @a start and arcing 
62          * through @a angle. The arc is centered at the origin 
63          * and drawn in the XY plane.
64          * 
65          * @param start The initial angle (in radians).
66          * @param angle The length of the arc (in radians).
67          * @param radius The arc radius.
68          * @param nsegments The number of segments to use in drawing the arc.
69          */
70 void glutil_draw_lined_arc      (float start, float angle, float radius, int nsegments);
71
72         /**
73          * Draw a filled arc with the given @a radius, 
74          * starting at angle @a start and arcing through 
75          * @a angle. The arc is centered at the origin 
76          * and drawn in the XY plane.
77          * 
78          * @param start The initial angle (in radians).
79          * @param angle The length of the arc (in radians).
80          * @param radius The arc radius.
81          * @param nsegments The number of segments to use in drawing the arc.
82          */
83 void glutil_draw_filled_arc     (float start, float angle, float radius, int nsegments);
84
85         /**
86          * Routines an integer value as obtained by glGetIntegerv.
87          * The param must cause only one value to be gotten from GL.
88          */
89 int glaGetOneInteger            (int param);
90
91         /**
92          * Routines a float value as obtained by glGetIntegerv.
93          * The param must cause only one value to be gotten from GL.
94          */
95 float glaGetOneFloat            (int param);
96
97         /**
98          * Functions like glRasterPos2i, except ensures that the resulting
99          * raster position is valid. @a known_good_x and @a known_good_y
100          * should be coordinates of a point known to be within the current
101          * view frustum.
102          * @attention This routine should be used when the distance of @a x 
103          * and @y away from the known good point is small (ie. for small icons
104          * and for bitmap characters), when drawing large+zoomed images it is
105          * possible for overflow to occur, the glaDrawPixelsSafe routine should
106          * be used instead.
107          */
108 void glaRasterPosSafe2f         (float x, float y, float known_good_x, float known_good_y);
109
110         /**
111          * Functions like a limited glDrawPixels, except ensures that 
112          * the image is displayed onscreen even if the @a x and @a y 
113          * coordinates for would be clipped. The routine respects the
114          * glPixelZoom values, pixel unpacking parameters are _not_ 
115          * respected.
116
117          * @attention This routine makes many assumptions: the rect data
118          * is expected to be in RGBA unsigned byte format, the coordinate
119          * (0.375, 0.375) is assumed to be within the view frustum, and the 
120          * modelview and projection matrices are assumed to define a 
121          * 1-to-1 mapping to screen space.
122          * @attention Furthmore, in the case of zoomed or unpixel aligned
123          * images extending outside the view frustum, but still within the 
124          * window, some portion of the image may be visible left and/or
125          * below of the given @a x and @a y coordinates. It is recommended
126          * to use the glScissor functionality if images are to be drawn
127          * with an inset view matrix.
128          */
129 void glaDrawPixelsSafe          (float x, float y, int img_w, int img_h, int row_w, int format, int type, void *rect);
130
131         /**
132          * Functions like a limited glDrawPixels, but actually draws the
133          * image using textures, which can be tremendously faster on low-end
134          * cards, and also avoids problems with the raster position being
135          * clipped when offscreen. The routine respects the glPixelZoom values, 
136          * pixel unpacking parameters are _not_ respected.
137
138          * @attention This routine makes many assumptions: the rect data
139          * is expected to be in RGBA byte or float format, and the 
140          * modelview and projection matrices are assumed to define a 
141          * 1-to-1 mapping to screen space.
142          */
143
144         /* only for float rects, converts to 32 bits and draws */
145 void glaDrawPixelsSafe_to32(float fx, float fy, int img_w, int img_h, int row_w, float *rectf);
146
147
148 void glaDrawPixelsTex           (float x, float y, int img_w, int img_h, int format, void *rect);
149
150         /* 2D Drawing Assistance */
151
152         /** Define a 2D area (viewport, scissor, matrices) for OpenGL rendering.
153          * This routine sets up an OpenGL state appropriate for drawing using
154          * both vertice (glVertex, etc) and raster (glRasterPos, glRect) commands.
155          * All coordinates should be at integer positions. There is little to
156          * no reason to use glVertex2f etc. functions during 2D rendering, and
157          * thus no reason to +-0.5 the coordinates or perform other silly
158          * tricks.
159          *
160          * @param screen_rect The screen rectangle to be defined for 2D drawing.
161          */
162 void glaDefine2DArea            (struct rcti *screen_rect);
163
164 typedef struct gla2DDrawInfo gla2DDrawInfo;
165
166         /** Save the current OpenGL state and initialize OpenGL for 2D
167          * rendering. glaEnd2DDraw should be called on the returned structure
168          * to free it and to return OpenGL to its previous state. The
169          * scissor rectangle is set to match the viewport.
170          *
171          * This routine sets up an OpenGL state appropriate for drawing using
172          * both vertice (glVertex, etc) and raster (glRasterPos, glRect) commands.
173          * All coordinates should be at integer positions. There is little to
174          * no reason to use glVertex2f etc. functions during 2D rendering, and
175          * thus no reason to +-0.5 the coordinates or perform other silly
176          * tricks.
177          *
178          * @param screen_rect The screen rectangle to be used for 2D drawing.
179          * @param world_rect The world rectangle that the 2D area represented
180          * by @a screen_rect is supposed to represent. If NULL it is assumed the
181          * world has a 1 to 1 mapping to the screen.
182          */
183 gla2DDrawInfo*  glaBegin2DDraw                  (struct rcti *screen_rect, struct rctf *world_rect);
184
185         /** Translate the (@a wo_x, @a wo_y) point from world coordinates into screen space. */
186 void                    gla2DDrawTranslatePt    (gla2DDrawInfo *di, float wo_x, float wo_y, int *sc_x_r, int *sc_y_r);
187
188         /** Translate the @a world point from world coordiantes into screen space. */
189 void                    gla2DDrawTranslatePtv   (gla2DDrawInfo *di, float world[2], int screen_r[2]);
190
191         /* Restores the previous OpenGL state and free's the auxilary
192          * gla data.
193          */
194 void                    glaEnd2DDraw                    (gla2DDrawInfo *di);
195
196         /** Adjust the transformation mapping of a 2d area */
197 void gla2DGetMap(gla2DDrawInfo *di, struct rctf *rect);
198 void gla2DSetMap(gla2DDrawInfo *di, struct rctf *rect);
199
200
201 /* use this for platform hacks. glPointSize is solved here */
202 void bglBegin(int mode);
203 void bglEnd(void);
204 void bglVertex3fv(float *vec);
205 void bglVertex3f(float x, float y, float z);
206 void bglVertex2fv(float *vec);
207 /* intel gfx cards frontbuffer problem */
208 void bglFlush(void);
209 int is_a_really_crappy_intel_card(void);
210 void set_inverted_drawing(int enable);
211
212
213 /* own working polygon offset */
214 void bglPolygonOffset(float dist);
215
216 /* For caching opengl matrices (gluProject/gluUnProject) */
217 typedef struct bglMats {
218         double modelview[16];
219         double projection[16];
220         int viewport[4];
221 } bglMats;
222 void bgl_get_mats(bglMats *mats);
223
224 #endif /* BIF_GLUTIL_H */
225