31f89063f058224bdb78e710db18ddb8558a5cdd
[blender-staging.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 void fdrawcheckerboard(float x1, float y1, float x2, float y2);
51
52 /* OpenGL stipple defines */
53 /* OpenGL stipple defines */
54 extern const unsigned char stipple_halftone[128];
55 extern const unsigned char stipple_quarttone[128];
56 extern const unsigned char stipple_diag_stripes_pos[128];
57 extern const unsigned char stipple_diag_stripes_neg[128];
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 \a 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  * (GLA_PIXEL_OFS, GLA_PIXEL_OFS) is assumed to be within the view frustum,
120  * and the modelview and projection matrices are assumed to define a
121  * 1-to-1 mapping to screen space.
122  * \attention Furthermore, 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 void glaDrawPixelsTex(float x, float y, int img_w, int img_h, int format, void *rect);
145
146 void glaDrawPixelsTexScaled(float x, float y, int img_w, int img_h, int format, void *rect, float scaleX, float scaleY);
147
148 /* 2D Drawing Assistance */
149
150 /** Define a 2D area (viewport, scissor, matrices) for OpenGL rendering.
151  *
152  * glwDefine2DArea and glaBegin2DDraw set up an OpenGL state appropriate
153  * for drawing using both vertice (Vertex, etc) and raster (RasterPos, Rect)
154  * commands. All coordinates should be at integer positions. There is little
155  * to no reason to use glVertex2f etc. functions during 2D rendering, and
156  * thus no reason to +-0.5 the coordinates or perform other silly
157  * tricks.
158  *
159  * \param screen_rect The screen rectangle to be defined for 2D drawing.
160  */
161 void glaDefine2DArea(struct rcti *screen_rect);
162
163 typedef struct gla2DDrawInfo gla2DDrawInfo;
164
165 /** Save the current OpenGL state and initialize OpenGL for 2D
166  * rendering. glaEnd2DDraw should be called on the returned structure
167  * to free it and to return OpenGL to its previous state. The
168  * scissor rectangle is set to match the viewport.
169  *
170  * See glaDefine2DArea for an explanation of why this function uses integers.
171  *
172  * \param screen_rect The screen rectangle to be used for 2D drawing.
173  * \param world_rect The world rectangle that the 2D area represented
174  * by \a screen_rect is supposed to represent. If NULL it is assumed the
175  * world has a 1 to 1 mapping to the screen.
176  */
177 gla2DDrawInfo  *glaBegin2DDraw(struct rcti *screen_rect, struct rctf *world_rect);
178
179 /** Translate the (\a wo_x, \a wo_y) point from world coordinates into screen space. */
180 void            gla2DDrawTranslatePt(gla2DDrawInfo *di, float wo_x, float wo_y, int *sc_x_r, int *sc_y_r);
181
182 /** Translate the \a world point from world coordiantes into screen space. */
183 void gla2DDrawTranslatePtv(gla2DDrawInfo * di, float world[2], int screen_r[2]);
184
185 /* Restores the previous OpenGL state and free's the auxilary
186  * gla data.
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
194
195 /* use this for platform hacks. glPointSize is solved here */
196 void bglBegin(int mode);
197 void bglEnd(void);
198 // int bglPointHack(void); /* UNUSED */
199 void bglVertex3fv(const float vec[3]);
200 void bglVertex3f(float x, float y, float z);
201 void bglVertex2fv(const float vec[2]);
202 /* intel gfx cards frontbuffer problem */
203 // void bglFlush(void); /* UNUSED */
204 void set_inverted_drawing(int enable);
205 void setlinestyle(int nr);
206
207 /* own working polygon offset */
208 void bglPolygonOffset(float viewdist, float dist);
209
210 /* For caching opengl matrices (gluProject/gluUnProject) */
211 typedef struct bglMats {
212         double modelview[16];
213         double projection[16];
214         int viewport[4];
215 } bglMats;
216 void bgl_get_mats(bglMats *mats);
217
218 #endif /* __BIF_GLUTIL_H__ */
219