Committing patch "[#27676] Change window size/resolution in realtime" by me.
[blender-staging.git] / source / blender / python / generic / bgl.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  * This is a new part of Blender.
22  *
23  * Contributor(s): Willian P. Germano
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/python/generic/bgl.h
29  *  \ingroup pygen
30  */
31
32
33 /* This is the Blender.BGL part of opy_draw.c, from the old bpython/intern
34  * dir, with minor changes to adapt it to the new Python implementation.
35  * The BGL submodule "wraps" OpenGL functions and constants, allowing script
36  * writers to make OpenGL calls in their Python scripts for Blender.  The
37  * more important original comments are marked with an @ symbol. */
38
39 #ifndef BGL_H
40 #define BGL_H
41
42 PyObject *BPyInit_bgl(void);
43
44 /*@ Create a buffer object */
45 /*@ dimensions is an array of ndimensions integers representing the size of each dimension */
46 /*@ initbuffer if not NULL holds a contiguous buffer with the correct format from which the buffer will be initialized */
47 struct _Buffer *BGL_MakeBuffer( int type, int ndimensions, int *dimensions, void *initbuffer );
48 /*@ Return the size of buffer element, type must be one of GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE */
49 /*@ returns -1 otherwise */
50 int BGL_typeSize( int type );
51
52 /*@ Buffer Object */
53 /*@ For Python access to OpenGL functions requiring a pointer. */
54 typedef struct _Buffer {
55         PyObject_VAR_HEAD 
56         PyObject *parent;
57
58         int type;               /* GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT */
59         int ndimensions;
60         int *dimensions;
61
62         union {
63                 char *asbyte;
64                 short *asshort;
65                 int *asint;
66                 float *asfloat;
67                 double *asdouble;
68
69                 void *asvoid;
70         } buf;
71 } Buffer;
72
73 /*@ The type object */
74 extern PyTypeObject BGL_bufferType;
75
76 /*@ By golly George! It looks like fancy pants macro time!!! */
77
78 /*
79 #define int_str       "i"
80 #define int_var(number)   bgl_int##number
81 #define int_ref(number)   &bgl_int##number
82 #define int_def(number)   int int_var(number)
83
84 #define float_str     "f"
85 #define float_var(number) bgl_float##number
86 #define float_ref(number) &bgl_float##number
87 #define float_def(number) float float_var(number)
88 */
89
90 /* TYPE_str is the string to pass to Py_ArgParse (for the format) */
91 /* TYPE_var is the name to pass to the GL function */
92 /* TYPE_ref is the pointer to pass to Py_ArgParse (to store in) */
93 /* TYPE_def is the C initialization of the variable */
94
95 #define void_str      ""
96 #define void_var(num)
97 #define void_ref(num)   &bgl_var##num
98 #define void_def(num)   char bgl_var##num
99
100 #define buffer_str      "O!"
101 #define buffer_var(number)  (bgl_buffer##number)->buf.asvoid
102 #define buffer_ref(number)  &BGL_bufferType, &bgl_buffer##number
103 #define buffer_def(number)  Buffer *bgl_buffer##number
104
105 /* GL Pointer fields, handled by buffer type */
106 /* GLdoubleP, GLfloatP, GLintP, GLuintP, GLshortP */
107
108 #define GLbooleanP_str      "O!"
109 #define GLbooleanP_var(number)  (bgl_buffer##number)->buf.asvoid
110 #define GLbooleanP_ref(number)  &BGL_bufferType, &bgl_buffer##number
111 #define GLbooleanP_def(number)  Buffer *bgl_buffer##number
112
113 #define GLbyteP_str     "O!"
114 #define GLbyteP_var(number) (bgl_buffer##number)->buf.asvoid
115 #define GLbyteP_ref(number) &BGL_bufferType, &bgl_buffer##number
116 #define GLbyteP_def(number) Buffer *bgl_buffer##number
117
118 #define GLubyteP_str      "O!"
119 #define GLubyteP_var(number)  (bgl_buffer##number)->buf.asvoid
120 #define GLubyteP_ref(number)  &BGL_bufferType, &bgl_buffer##number
121 #define GLubyteP_def(number)  Buffer *bgl_buffer##number
122
123 #define GLintP_str      "O!"
124 #define GLintP_var(number)  (bgl_buffer##number)->buf.asvoid
125 #define GLintP_ref(number)  &BGL_bufferType, &bgl_buffer##number
126 #define GLintP_def(number)  Buffer *bgl_buffer##number
127
128 #define GLuintP_str     "O!"
129 #define GLuintP_var(number) (bgl_buffer##number)->buf.asvoid
130 #define GLuintP_ref(number) &BGL_bufferType, &bgl_buffer##number
131 #define GLuintP_def(number) Buffer *bgl_buffer##number
132
133 #define GLshortP_str      "O!"
134 #define GLshortP_var(number)  (bgl_buffer##number)->buf.asvoid
135 #define GLshortP_ref(number)  &BGL_bufferType, &bgl_buffer##number
136 #define GLshortP_def(number)  Buffer *bgl_buffer##number
137
138 #define GLushortP_str     "O!"
139 #define GLushortP_var(number) (bgl_buffer##number)->buf.asvoid
140 #define GLushortP_ref(number) &BGL_bufferType, &bgl_buffer##number
141 #define GLushortP_def(number) Buffer *bgl_buffer##number
142
143 #define GLfloatP_str      "O!"
144 #define GLfloatP_var(number)  (bgl_buffer##number)->buf.asvoid
145 #define GLfloatP_ref(number)  &BGL_bufferType, &bgl_buffer##number
146 #define GLfloatP_def(number)  Buffer *bgl_buffer##number
147
148 #define GLdoubleP_str     "O!"
149 #define GLdoubleP_var(number) (bgl_buffer##number)->buf.asvoid
150 #define GLdoubleP_ref(number) &BGL_bufferType, &bgl_buffer##number
151 #define GLdoubleP_def(number) Buffer *bgl_buffer##number
152
153 #define GLclampfP_str     "O!"
154 #define GLclampfP_var(number) (bgl_buffer##number)->buf.asvoid
155 #define GLclampfP_ref(number) &BGL_bufferType, &bgl_buffer##number
156 #define GLclampfP_def(number) Buffer *bgl_buffer##number
157
158 #define GLvoidP_str     "O!"
159 #define GLvoidP_var(number) (bgl_buffer##number)->buf.asvoid
160 #define GLvoidP_ref(number) &BGL_bufferType, &bgl_buffer##number
161 #define GLvoidP_def(number) Buffer *bgl_buffer##number
162
163 #define buffer_str      "O!"
164 #define buffer_var(number)  (bgl_buffer##number)->buf.asvoid
165 #define buffer_ref(number)  &BGL_bufferType, &bgl_buffer##number
166 #define buffer_def(number)  Buffer *bgl_buffer##number
167
168 /*@The standard GL typedefs are used as prototypes, we can't
169  * use the GL type directly because Py_ArgParse expects normal
170  * C types.
171  * 
172  * Py_ArgParse doesn't grok writing into unsigned variables, 
173  * so we use signed everything (even stuff that should be unsigned.
174  */
175
176 /* typedef unsigned int GLenum; */
177 #define GLenum_str      "i"
178 #define GLenum_var(num)   bgl_var##num
179 #define GLenum_ref(num)   &bgl_var##num
180 #define GLenum_def(num)   /* unsigned */ int GLenum_var(num)
181
182 /* typedef unsigned int GLboolean; */
183 #define GLboolean_str     "b"
184 #define GLboolean_var(num)    bgl_var##num
185 #define GLboolean_ref(num)    &bgl_var##num
186 #define GLboolean_def(num)    /* unsigned */ char GLboolean_var(num)
187
188 /* typedef unsigned int GLbitfield; */
189 #define GLbitfield_str      "i"
190 #define GLbitfield_var(num)   bgl_var##num
191 #define GLbitfield_ref(num)   &bgl_var##num
192 #define GLbitfield_def(num)   /* unsigned */ int GLbitfield_var(num)
193
194 /* typedef signed char GLbyte; */
195 #define GLbyte_str        "b"
196 #define GLbyte_var(num)     bgl_var##num
197 #define GLbyte_ref(num)     &bgl_var##num
198 #define GLbyte_def(num)     signed char GLbyte_var(num)
199
200 /* typedef short GLshort; */
201 #define GLshort_str       "h"
202 #define GLshort_var(num)    bgl_var##num
203 #define GLshort_ref(num)    &bgl_var##num
204 #define GLshort_def(num)    short GLshort_var(num)
205
206 /* typedef int GLint; */
207 #define GLint_str       "i"
208 #define GLint_var(num)      bgl_var##num
209 #define GLint_ref(num)      &bgl_var##num
210 #define GLint_def(num)      int GLint_var(num)
211
212 /* typedef int GLsizei; */
213 #define GLsizei_str       "i"
214 #define GLsizei_var(num)    bgl_var##num
215 #define GLsizei_ref(num)    &bgl_var##num
216 #define GLsizei_def(num)    int GLsizei_var(num)
217
218 /* typedef unsigned char GLubyte; */
219 #define GLubyte_str       "B"
220 #define GLubyte_var(num)    bgl_var##num
221 #define GLubyte_ref(num)    &bgl_var##num
222 #define GLubyte_def(num)    /* unsigned */ char GLubyte_var(num)
223
224 /* typedef unsigned short GLushort; */
225 #define GLushort_str      "H"
226 #define GLushort_var(num)   bgl_var##num
227 #define GLushort_ref(num)   &bgl_var##num
228 #define GLushort_def(num)   /* unsigned */ short GLushort_var(num)
229
230 /* typedef unsigned int GLuint; */
231 #define GLuint_str        "I"
232 #define GLuint_var(num)     bgl_var##num
233 #define GLuint_ref(num)     &bgl_var##num
234 #define GLuint_def(num)     /* unsigned */ int GLuint_var(num)
235
236 /* typedef float GLfloat; */
237 #define GLfloat_str       "f"
238 #define GLfloat_var(num)    bgl_var##num
239 #define GLfloat_ref(num)    &bgl_var##num
240 #define GLfloat_def(num)    float GLfloat_var(num)
241
242 /* typedef float GLclampf; */
243 #define GLclampf_str      "f"
244 #define GLclampf_var(num)   bgl_var##num
245 #define GLclampf_ref(num)   &bgl_var##num
246 #define GLclampf_def(num)   float GLclampf_var(num)
247
248 /* typedef double GLdouble; */
249 #define GLdouble_str      "d"
250 #define GLdouble_var(num)   bgl_var##num
251 #define GLdouble_ref(num)   &bgl_var##num
252 #define GLdouble_def(num)   double GLdouble_var(num)
253
254 /* typedef double GLclampd; */
255 #define GLclampd_str      "d"
256 #define GLclampd_var(num)   bgl_var##num
257 #define GLclampd_ref(num)   &bgl_var##num
258 #define GLclampd_def(num)   double GLclampd_var(num)
259
260 /* typedef void GLvoid; */
261 /* #define GLvoid_str       "" */
262 /* #define GLvoid_var(num)      bgl_var##num */
263 /* #define GLvoid_ref(num)      &bgl_var##num */
264 /* #define GLvoid_def(num)      char bgl_var##num */
265
266 #define arg_def1(a1)          a1##_def(1)
267 #define arg_def2(a1, a2)        arg_def1(a1); a2##_def(2)
268 #define arg_def3(a1, a2, a3)      arg_def2(a1, a2); a3##_def(3)
269 #define arg_def4(a1, a2, a3, a4)    arg_def3(a1, a2, a3); a4##_def(4)
270 #define arg_def5(a1, a2, a3, a4, a5)  arg_def4(a1, a2, a3, a4); a5##_def(5)
271 #define arg_def6(a1, a2, a3, a4, a5, a6)arg_def5(a1, a2, a3, a4, a5); a6##_def(6)
272 #define arg_def7(a1, a2, a3, a4, a5, a6, a7)arg_def6(a1, a2, a3, a4, a5, a6); a7##_def(7)
273 #define arg_def8(a1, a2, a3, a4, a5, a6, a7, a8)arg_def7(a1, a2, a3, a4, a5, a6, a7); a8##_def(8)
274 #define arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_def8(a1, a2, a3, a4, a5, a6, a7, a8); a9##_def(9)
275 #define arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9); a10##_def(10)
276
277 #define arg_var1(a1)          a1##_var(1)
278 #define arg_var2(a1, a2)        arg_var1(a1), a2##_var(2)
279 #define arg_var3(a1, a2, a3)      arg_var2(a1, a2), a3##_var(3)
280 #define arg_var4(a1, a2, a3, a4)    arg_var3(a1, a2, a3), a4##_var(4)
281 #define arg_var5(a1, a2, a3, a4, a5)  arg_var4(a1, a2, a3, a4), a5##_var(5)
282 #define arg_var6(a1, a2, a3, a4, a5, a6)arg_var5(a1, a2, a3, a4, a5), a6##_var(6)
283 #define arg_var7(a1, a2, a3, a4, a5, a6, a7)arg_var6(a1, a2, a3, a4, a5, a6), a7##_var(7)
284 #define arg_var8(a1, a2, a3, a4, a5, a6, a7, a8)arg_var7(a1, a2, a3, a4, a5, a6, a7), a8##_var(8)
285 #define arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_var8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_var(9)
286 #define arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_var(10)
287
288 #define arg_ref1(a1)          a1##_ref(1)
289 #define arg_ref2(a1, a2)        arg_ref1(a1), a2##_ref(2)
290 #define arg_ref3(a1, a2, a3)      arg_ref2(a1, a2), a3##_ref(3)
291 #define arg_ref4(a1, a2, a3, a4)    arg_ref3(a1, a2, a3), a4##_ref(4)
292 #define arg_ref5(a1, a2, a3, a4, a5)  arg_ref4(a1, a2, a3, a4), a5##_ref(5)
293 #define arg_ref6(a1, a2, a3, a4, a5, a6)arg_ref5(a1, a2, a3, a4, a5), a6##_ref(6)
294 #define arg_ref7(a1, a2, a3, a4, a5, a6, a7)arg_ref6(a1, a2, a3, a4, a5, a6), a7##_ref(7)
295 #define arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8)arg_ref7(a1, a2, a3, a4, a5, a6, a7), a8##_ref(8)
296 #define arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_ref(9)
297 #define arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_ref(10)
298
299 #define arg_str1(a1)          a1##_str
300 #define arg_str2(a1, a2)        arg_str1(a1) a2##_str
301 #define arg_str3(a1, a2, a3)      arg_str2(a1, a2) a3##_str
302 #define arg_str4(a1, a2, a3, a4)    arg_str3(a1, a2, a3) a4##_str
303 #define arg_str5(a1, a2, a3, a4, a5)  arg_str4(a1, a2, a3, a4) a5##_str
304 #define arg_str6(a1, a2, a3, a4, a5, a6)arg_str5(a1, a2, a3, a4, a5) a6##_str
305 #define arg_str7(a1, a2, a3, a4, a5, a6, a7)arg_str6(a1, a2, a3, a4, a5, a6) a7##_str
306 #define arg_str8(a1, a2, a3, a4, a5, a6, a7, a8)arg_str7(a1, a2, a3, a4, a5, a6, a7) a8##_str
307 #define arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) a9##_str
308 #define arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) a10##_str
309
310 #define ret_def_void
311 #define ret_set_void
312 #define ret_ret_void    return Py_INCREF(Py_None), Py_None
313
314 #define ret_def_GLint   int ret_int
315 #define ret_set_GLint   ret_int=
316 #define ret_ret_GLint   return PyLong_FromLong(ret_int)
317
318 #define ret_def_GLuint    unsigned int ret_uint
319 #define ret_set_GLuint    ret_uint=
320 #define ret_ret_GLuint    return PyLong_FromLong((long) ret_uint)
321
322 #define ret_def_GLenum    unsigned int ret_uint
323 #define ret_set_GLenum    ret_uint=
324 #define ret_ret_GLenum    return PyLong_FromLong((long) ret_uint)
325
326 #define ret_def_GLboolean unsigned char ret_bool
327 #define ret_set_GLboolean ret_bool=
328 #define ret_ret_GLboolean return PyLong_FromLong((long) ret_bool)
329
330 #define ret_def_GLstring  const unsigned char *ret_str;
331 #define ret_set_GLstring  ret_str=
332
333 #define ret_ret_GLstring                                                      \
334         if (ret_str) {                                                            \
335                 return PyUnicode_FromString((const char *)ret_str);                   \
336         }                                                                         \
337         else {                                                                    \
338                 PyErr_SetString(PyExc_AttributeError, "could not get opengl string"); \
339                 return NULL;                                                          \
340         }                                                                         \
341
342 #endif /* BGL_H */