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