bb64e9caa8fa714396b2024d66154df6dcf2b9ca
[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 WIN32
45 #include "blenpluginapi\util.h"
46 #else
47 #include "blenpluginapi/util.h"
48 #endif
49 #include "iff.h"
50 #include "plugin.h"
51 #include "MEM_guardedalloc.h"
52
53 #include "BLI_blenlib.h"  /* util and noise functions */
54 #include "IMB_imbuf.h"    /* image buffer stuff       */
55
56 /* -------------------------------------------------------------------------- */
57 /* stuff from util.h                                                          */ 
58 /* -------------------------------------------------------------------------- */
59
60 void *mallocN(int len, char *str)
61 {
62         return MEM_mallocN(len, str);
63 }
64
65 void *callocN(int len, char *str)
66 {
67         return MEM_callocN(len, str);
68 }
69
70 short freeN(void *vmemh)
71 {
72         return MEM_freeN(vmemh);
73 }
74
75 /* -------------------------------------------------------------------------- */
76 /* stuff from iff.h                                                           */ 
77 /* -------------------------------------------------------------------------- */
78
79 struct ImBuf *allocImBuf(short x,
80                                                  short y,
81                                                  uchar d,
82                                                  uint flags,
83                                                  uchar bitmap)
84 {
85         return IMB_allocImBuf(x, y, d, flags, bitmap);
86 }
87
88
89 struct ImBuf *dupImBuf(struct ImBuf *ib)
90 {
91         return IMB_dupImBuf(ib);
92 }
93         
94 void freeImBuf(struct ImBuf* ib)
95 {
96         IMB_freeImBuf(ib);
97 }
98
99 short converttocmap(struct ImBuf* ibuf)
100 {
101         return IMB_converttocmap(ibuf);
102 }
103
104 short saveiff(struct ImBuf *ib,
105                           char *c,
106                           int i)
107 {
108         return IMB_saveiff(ib, c, i);
109 }
110
111 struct ImBuf *loadiffmem(int *mem,int flags)
112 {
113         return IMB_loadiffmem(mem, flags);
114 }
115         
116 struct ImBuf *loadifffile(int a,
117                                                   int b)
118 {
119         return IMB_loadifffile(a, b);
120 }
121
122 struct ImBuf *loadiffname(char *n,
123                                                   int flags)
124 {
125         return IMB_loadiffname(n, flags);
126 }
127         
128 struct ImBuf *testiffname(char *n,
129                                                   int flags)
130 {
131         return IMB_testiffname(n, flags);
132 }
133
134 struct ImBuf *onehalf(struct ImBuf *ib)
135 {
136         return IMB_onehalf(ib);
137 }
138
139 struct ImBuf *onethird(struct ImBuf *ib)
140 {
141         return IMB_onethird(ib);
142 }
143
144 struct ImBuf *halflace(struct ImBuf *ib)
145 {
146         return IMB_halflace(ib);
147 }
148
149 struct ImBuf *half_x(struct ImBuf *ib)
150 {
151         return IMB_half_x(ib);
152 }
153
154 struct ImBuf *half_y(struct ImBuf *ib)
155 {
156         return IMB_half_y(ib);
157 }
158
159 struct ImBuf *double_x(struct ImBuf *ib)
160 {
161         return IMB_double_x(ib);
162 }
163
164 struct ImBuf *double_y(struct ImBuf *ib)
165 {
166         return IMB_double_y(ib);
167 }
168
169 struct ImBuf *double_fast_x(struct ImBuf *ib)
170 {
171         return IMB_double_fast_x(ib);
172 }
173
174 struct ImBuf *double_fast_y(struct ImBuf *ib)
175 {
176         return IMB_double_fast_y(ib);
177 }
178
179 int ispic(char * name)
180 {
181         return IMB_ispic(name);
182 }
183
184 void dit2(struct ImBuf *ib,
185                    short a,
186                    short b)
187 {
188         IMB_dit2(ib, a, b);
189 }
190
191 void dit0(struct ImBuf *ib,
192                    short a,
193                    short b)
194 {
195         IMB_dit0(ib, a, b);
196 }
197
198 /* still the same name */
199 /*  void (*ditherfunc)(struct ImBuf *, short, short){} */
200
201 struct ImBuf *scaleImBuf(struct ImBuf *ib,
202                                                  short nx,
203                                                  short ny)
204 {
205         return IMB_scaleImBuf(ib, nx, ny);
206 }
207
208 struct ImBuf *scalefastImBuf(struct ImBuf *ib,
209                                                          short x,
210                                                          short y)
211 {
212         return IMB_scalefastImBuf(ib, x, y);
213 }
214
215
216 struct ImBuf *scalefieldImBuf(struct ImBuf *ib,
217                                                           short x,
218                                                           short y)
219 {
220         return IMB_scalefieldImBuf(ib, x, y);
221 }
222
223 struct ImBuf *scalefastfieldImBuf(struct ImBuf *ib,
224                                                                   short x,
225                                                                   short y)
226 {
227         return IMB_scalefastfieldImBuf(ib, x, y);
228 }
229
230         /* Extra ones that some NaN (read Ton) plugins use,
231          * even though they aren't in the header
232          */
233
234 void interlace(struct ImBuf *ibuf)
235 {
236         IMB_interlace(ibuf);
237 }
238
239 void gamwarp(struct ImBuf *ibuf, double gamma)
240 {
241         IMB_gamwarp(ibuf,gamma);
242 }
243          
244 void de_interlace(struct ImBuf *ib)
245 {
246         IMB_de_interlace(ib);
247 }
248
249 /* -------------------------------------------------------------------------- */
250 /* stuff from plugin.h                                                        */ 
251 /* -------------------------------------------------------------------------- */
252
253 /* These three need to be defined in the plugion itself. The plugin
254  * loader looks for these functions to check whether it can use the
255  * plugin. For sequences, something similar exists. */
256 /*  int plugin_tex_getversion(void); */
257 /*  int plugin_seq_getversion(void); */
258 /*  void plugin_getinfo(PluginInfo *); */
259
260 float hnoise(float noisesize,
261                          float x,
262                          float y,
263                          float z)
264 {
265         return BLI_hnoise(noisesize, x, y, z);
266 }
267
268 float hnoisep(float noisesize,
269                           float x,
270                           float y,
271                           float z)
272 {
273         return BLI_hnoisep(noisesize, x, y, z);
274 }
275
276 float turbulence(float noisesize,
277                                  float x,
278                                  float y,
279                                  float z,
280                                  int depth)
281 {
282         return BLI_turbulence(noisesize, x, y, z, depth);
283 }
284
285 float turbulence1(float noisesize,
286                                   float x,
287                                   float y,
288                                   float z,
289                                   int depth)
290 {
291         return BLI_turbulence1(noisesize, x, y, z, depth);
292 }
293
294 /* -------------------------------------------------------------------------- */
295
296         /* Stupid hack - force the inclusion of all of the
297          * above functions in the binary by 'using' each one...
298          * Otherwise they will not be imported from the archive
299          * library on Unix. -zr
300          */
301 int pluginapi_force_ref(void); 
302
303 int pluginapi_force_ref(void) 
304 {
305         return (int) mallocN +
306                 (int) callocN +
307                 (int) freeN +
308                 (int) allocImBuf +
309                 (int) dupImBuf +
310                 (int) freeImBuf +
311                 (int) converttocmap +
312                 (int) saveiff +
313                 (int) loadiffmem +
314                 (int) loadifffile +
315                 (int) loadiffname +
316                 (int) testiffname +
317                 (int) onehalf +
318                 (int) onethird +
319                 (int) halflace +
320                 (int) half_x +
321                 (int) half_y +
322                 (int) double_x +
323                 (int) double_y +
324                 (int) double_fast_x +
325                 (int) double_fast_y +
326                 (int) ispic +
327                 (int) dit2 +
328                 (int) dit0 +
329                 (int) scaleImBuf +
330                 (int) scalefastImBuf +
331                 (int) scalefieldImBuf +
332                 (int) scalefastfieldImBuf +
333                 (int) hnoise +
334                 (int) hnoisep +
335                 (int) turbulence +
336                 (int) turbulence1 +
337                 (int) de_interlace +
338                 (int) interlace +
339                 (int) gamwarp;
340 }