Some of the Makefiles had CPPFLAGS += LEVEL_(X)_C_WARNINGS
[blender.git] / source / blender / blenpluginapi / intern / pluginapi.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  * Wrappers for the plugin api. This api is up for removal.
32  */
33
34 /* There are four headers making up the plugin api:
35  * - floatpatch.h : Wraps math functions for mips platforms, no code
36  *                  required.
37  * - iff.h        : Defines, macros and functions for dealing
38  *                  with image buffer things.
39  * - plugin.h     : Wraps some plugin handling types, accesses noise
40  *                  functions.
41  * - util.h       : Useful defines, memory management.
42  */
43
44 #ifdef HAVE_CONFIG_H
45 #include <config.h>
46 #endif
47
48 #ifdef WIN32
49 #include "blenpluginapi\util.h"
50 #else
51 #include "util.h"
52 #endif
53 #include "iff.h"
54 #include "plugin.h"
55 #include "MEM_guardedalloc.h"
56
57 #include "BLI_blenlib.h"  /* util and noise functions */
58 #include "IMB_imbuf.h"    /* image buffer stuff       */
59
60 /* -------------------------------------------------------------------------- */
61 /* stuff from util.h                                                          */ 
62 /* -------------------------------------------------------------------------- */
63
64 void *mallocN(int len, char *str)
65 {
66         return MEM_mallocN(len, str);
67 }
68
69 void *callocN(int len, char *str)
70 {
71         return MEM_callocN(len, str);
72 }
73
74 short freeN(void *vmemh)
75 {
76         return MEM_freeN(vmemh);
77 }
78
79 /* -------------------------------------------------------------------------- */
80 /* stuff from iff.h                                                           */ 
81 /* -------------------------------------------------------------------------- */
82
83 struct ImBuf *allocImBuf(short x,
84                                                  short y,
85                                                  uchar d,
86                                                  uint flags,
87                                                  uchar bitmap)
88 {
89         return IMB_allocImBuf(x, y, d, flags, bitmap);
90 }
91
92
93 struct ImBuf *dupImBuf(struct ImBuf *ib)
94 {
95         return IMB_dupImBuf(ib);
96 }
97         
98 void freeImBuf(struct ImBuf* ib)
99 {
100         IMB_freeImBuf(ib);
101 }
102
103 short converttocmap(struct ImBuf* ibuf)
104 {
105         return IMB_converttocmap(ibuf);
106 }
107
108 short saveiff(struct ImBuf *ib,
109                           char *c,
110                           int i)
111 {
112         return IMB_saveiff(ib, c, i);
113 }
114
115 struct ImBuf *loadiffmem(int *mem,int flags)
116 {
117         return IMB_loadiffmem(mem, flags);
118 }
119         
120 struct ImBuf *loadifffile(int a,
121                                                   int b)
122 {
123         return IMB_loadifffile(a, b);
124 }
125
126 struct ImBuf *loadiffname(char *n,
127                                                   int flags)
128 {
129         return IMB_loadiffname(n, flags);
130 }
131         
132 struct ImBuf *testiffname(char *n,
133                                                   int flags)
134 {
135         return IMB_testiffname(n, flags);
136 }
137
138 struct ImBuf *onehalf(struct ImBuf *ib)
139 {
140         return IMB_onehalf(ib);
141 }
142
143 struct ImBuf *onethird(struct ImBuf *ib)
144 {
145         return IMB_onethird(ib);
146 }
147
148 struct ImBuf *halflace(struct ImBuf *ib)
149 {
150         return IMB_halflace(ib);
151 }
152
153 struct ImBuf *half_x(struct ImBuf *ib)
154 {
155         return IMB_half_x(ib);
156 }
157
158 struct ImBuf *half_y(struct ImBuf *ib)
159 {
160         return IMB_half_y(ib);
161 }
162
163 struct ImBuf *double_x(struct ImBuf *ib)
164 {
165         return IMB_double_x(ib);
166 }
167
168 struct ImBuf *double_y(struct ImBuf *ib)
169 {
170         return IMB_double_y(ib);
171 }
172
173 struct ImBuf *double_fast_x(struct ImBuf *ib)
174 {
175         return IMB_double_fast_x(ib);
176 }
177
178 struct ImBuf *double_fast_y(struct ImBuf *ib)
179 {
180         return IMB_double_fast_y(ib);
181 }
182
183 int ispic(char * name)
184 {
185         return IMB_ispic(name);
186 }
187
188 void dit2(struct ImBuf *ib,
189                    short a,
190                    short b)
191 {
192         IMB_dit2(ib, a, b);
193 }
194
195 void dit0(struct ImBuf *ib,
196                    short a,
197                    short b)
198 {
199         IMB_dit0(ib, a, b);
200 }
201
202 /* still the same name */
203 /*  void (*ditherfunc)(struct ImBuf *, short, short){} */
204
205 struct ImBuf *scaleImBuf(struct ImBuf *ib,
206                                                  short nx,
207                                                  short ny)
208 {
209         return IMB_scaleImBuf(ib, nx, ny);
210 }
211
212 struct ImBuf *scalefastImBuf(struct ImBuf *ib,
213                                                          short x,
214                                                          short y)
215 {
216         return IMB_scalefastImBuf(ib, x, y);
217 }
218
219
220 struct ImBuf *scalefieldImBuf(struct ImBuf *ib,
221                                                           short x,
222                                                           short y)
223 {
224         return IMB_scalefieldImBuf(ib, x, y);
225 }
226
227 struct ImBuf *scalefastfieldImBuf(struct ImBuf *ib,
228                                                                   short x,
229                                                                   short y)
230 {
231         return IMB_scalefastfieldImBuf(ib, x, y);
232 }
233
234         /* Extra ones that some NaN (read Ton) plugins use,
235          * even though they aren't in the header
236          */
237
238 void interlace(struct ImBuf *ibuf)
239 {
240         IMB_interlace(ibuf);
241 }
242
243 void gamwarp(struct ImBuf *ibuf, double gamma)
244 {
245         IMB_gamwarp(ibuf,gamma);
246 }
247          
248 void de_interlace(struct ImBuf *ib)
249 {
250         IMB_de_interlace(ib);
251 }
252
253 void rectop(struct ImBuf *dbuf,
254                         struct ImBuf *sbuf,
255                         int destx,
256                         int desty,
257                         int srcx,
258                         int srcy,
259                         int width,
260                         int height,
261                         void (*operation)(unsigned int *, unsigned int*, int, int),
262                         int value)
263 {
264         IMB_rectop(dbuf, sbuf, destx, desty, srcx, srcy, width, height, operation, value);
265 }
266
267 /* -------------------------------------------------------------------------- */
268 /* stuff from plugin.h                                                        */ 
269 /* -------------------------------------------------------------------------- */
270
271 /* These three need to be defined in the plugion itself. The plugin
272  * loader looks for these functions to check whether it can use the
273  * plugin. For sequences, something similar exists. */
274 /*  int plugin_tex_getversion(void); */
275 /*  int plugin_seq_getversion(void); */
276 /*  void plugin_getinfo(PluginInfo *); */
277
278 float hnoise(float noisesize,
279                          float x,
280                          float y,
281                          float z)
282 {
283         return BLI_hnoise(noisesize, x, y, z);
284 }
285
286 float hnoisep(float noisesize,
287                           float x,
288                           float y,
289                           float z)
290 {
291         return BLI_hnoisep(noisesize, x, y, z);
292 }
293
294 float turbulence(float noisesize,
295                                  float x,
296                                  float y,
297                                  float z,
298                                  int depth)
299 {
300         return BLI_turbulence(noisesize, x, y, z, depth);
301 }
302
303 float turbulence1(float noisesize,
304                                   float x,
305                                   float y,
306                                   float z,
307                                   int depth)
308 {
309         return BLI_turbulence1(noisesize, x, y, z, depth);
310 }
311
312 /* -------------------------------------------------------------------------- */
313
314         /* Stupid hack - force the inclusion of all of the
315          * above functions in the binary by 'using' each one...
316          * Otherwise they will not be imported from the archive
317          * library on Unix. -zr
318          */
319 int pluginapi_force_ref(void) 
320 {
321         return (int) mallocN +
322                 (int) callocN +
323                 (int) freeN +
324                 (int) allocImBuf +
325                 (int) dupImBuf +
326                 (int) freeImBuf +
327                 (int) converttocmap +
328                 (int) saveiff +
329                 (int) loadiffmem +
330                 (int) loadifffile +
331                 (int) loadiffname +
332                 (int) testiffname +
333                 (int) onehalf +
334                 (int) onethird +
335                 (int) halflace +
336                 (int) half_x +
337                 (int) half_y +
338                 (int) double_x +
339                 (int) double_y +
340                 (int) double_fast_x +
341                 (int) double_fast_y +
342                 (int) ispic +
343                 (int) dit2 +
344                 (int) dit0 +
345                 (int) scaleImBuf +
346                 (int) scalefastImBuf +
347                 (int) scalefieldImBuf +
348                 (int) scalefastfieldImBuf +
349                 (int) hnoise +
350                 (int) hnoisep +
351                 (int) turbulence +
352                 (int) turbulence1 +
353                 (int) de_interlace +
354                 (int) interlace +
355                 (int) gamwarp +
356                 (int) rectop;
357 }