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