← Back to branch summary

~diresu/blender/blender-command-port

« back to all changes in this revision

Viewing changes to source/blender/python/api2_2x/BGL.h

  • Committer: theeth
  • Date: 2008-10-14 16:52:04 UTC
  • Revision ID: vcs-imports@canonical.com-20081014165204-r32w2gm6s0osvdhn
copy back trunk

Show diffs side-by-side

added added

removed removed

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