Logo Search packages:      
Sourcecode: blender version File versions

pluginapi.c

/**
 * $Id: pluginapi.c,v 1.4 2003/04/30 18:38:47 sirdude Exp $
 *
 * ***** BEGIN GPL/BL DUAL 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. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
 * Wrappers for the plugin api. This api is up for removal.
 */

/* There are four headers making up the plugin api:
 * - floatpatch.h : Wraps math functions for mips platforms, no code
 *                  required.
 * - iff.h        : Defines, macros and functions for dealing
 *                  with image buffer things.
 * - plugin.h     : Wraps some plugin handling types, accesses noise
 *                  functions.
 * - util.h       : Useful defines, memory management.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef WIN32
#include "blenpluginapi\util.h"
#else
#include "util.h"
#endif
#include "iff.h"
#include "plugin.h"
#include "MEM_guardedalloc.h"

#include "BLI_blenlib.h"  /* util and noise functions */
#include "IMB_imbuf.h"    /* image buffer stuff       */

/* -------------------------------------------------------------------------- */
/* stuff from util.h                                                          */ 
/* -------------------------------------------------------------------------- */

void *mallocN(int len, char *str)
{
      return MEM_mallocN(len, str);
}

void *callocN(int len, char *str)
{
      return MEM_callocN(len, str);
}

short freeN(void *vmemh)
{
      return MEM_freeN(vmemh);
}

/* -------------------------------------------------------------------------- */
/* stuff from iff.h                                                           */ 
/* -------------------------------------------------------------------------- */

struct ImBuf *allocImBuf(short x,
                                     short y,
                                     uchar d,
                                     uint flags,
                                     uchar bitmap)
{
      return IMB_allocImBuf(x, y, d, flags, bitmap);
}


struct ImBuf *dupImBuf(struct ImBuf *ib)
{
      return IMB_dupImBuf(ib);
}
      
void freeImBuf(struct ImBuf* ib)
{
      IMB_freeImBuf(ib);
}

short converttocmap(struct ImBuf* ibuf)
{
      return IMB_converttocmap(ibuf);
}

short saveiff(struct ImBuf *ib,
                    char *c,
                    int i)
{
      return IMB_saveiff(ib, c, i);
}

struct ImBuf *loadiffmem(int *mem,int flags)
{
      return IMB_loadiffmem(mem, flags);
}
      
struct ImBuf *loadifffile(int a,
                                      int b)
{
      return IMB_loadifffile(a, b);
}

struct ImBuf *loadiffname(char *n,
                                      int flags)
{
      return IMB_loadiffname(n, flags);
}
      
struct ImBuf *testiffname(char *n,
                                      int flags)
{
      return IMB_testiffname(n, flags);
}

struct ImBuf *onehalf(struct ImBuf *ib)
{
      return IMB_onehalf(ib);
}

struct ImBuf *onethird(struct ImBuf *ib)
{
      return IMB_onethird(ib);
}

struct ImBuf *halflace(struct ImBuf *ib)
{
      return IMB_halflace(ib);
}

struct ImBuf *half_x(struct ImBuf *ib)
{
      return IMB_half_x(ib);
}

struct ImBuf *half_y(struct ImBuf *ib)
{
      return IMB_half_y(ib);
}

struct ImBuf *double_x(struct ImBuf *ib)
{
      return IMB_double_x(ib);
}

struct ImBuf *double_y(struct ImBuf *ib)
{
      return IMB_double_y(ib);
}

struct ImBuf *double_fast_x(struct ImBuf *ib)
{
      return IMB_double_fast_x(ib);
}

struct ImBuf *double_fast_y(struct ImBuf *ib)
{
      return IMB_double_fast_y(ib);
}

int ispic(char * name)
{
      return IMB_ispic(name);
}

void dit2(struct ImBuf *ib,
               short a,
               short b)
{
      IMB_dit2(ib, a, b);
}

void dit0(struct ImBuf *ib,
               short a,
               short b)
{
      IMB_dit0(ib, a, b);
}

/* still the same name */
/*  void (*ditherfunc)(struct ImBuf *, short, short){} */

struct ImBuf *scaleImBuf(struct ImBuf *ib,
                                     short nx,
                                     short ny)
{
      return IMB_scaleImBuf(ib, nx, ny);
}

struct ImBuf *scalefastImBuf(struct ImBuf *ib,
                                           short x,
                                           short y)
{
      return IMB_scalefastImBuf(ib, x, y);
}


struct ImBuf *scalefieldImBuf(struct ImBuf *ib,
                                            short x,
                                            short y)
{
      return IMB_scalefieldImBuf(ib, x, y);
}

struct ImBuf *scalefastfieldImBuf(struct ImBuf *ib,
                                                  short x,
                                                  short y)
{
      return IMB_scalefastfieldImBuf(ib, x, y);
}

      /* Extra ones that some NaN (read Ton) plugins use,
       * even though they aren't in the header
       */

void interlace(struct ImBuf *ibuf)
{
      IMB_interlace(ibuf);
}

void gamwarp(struct ImBuf *ibuf, double gamma)
{
      IMB_gamwarp(ibuf,gamma);
}
       
void de_interlace(struct ImBuf *ib)
{
      IMB_de_interlace(ib);
}

void rectop(struct ImBuf *dbuf,
                  struct ImBuf *sbuf,
                  int destx,
                  int desty,
                  int srcx,
                  int srcy,
                  int width,
                  int height,
                  void (*operation)(unsigned int *, unsigned int*, int, int),
                  int value)
{
      IMB_rectop(dbuf, sbuf, destx, desty, srcx, srcy, width, height, operation, value);
}

/* -------------------------------------------------------------------------- */
/* stuff from plugin.h                                                        */ 
/* -------------------------------------------------------------------------- */

/* These three need to be defined in the plugion itself. The plugin
 * loader looks for these functions to check whether it can use the
 * plugin. For sequences, something similar exists. */
/*  int plugin_tex_getversion(void); */
/*  int plugin_seq_getversion(void); */
/*  void plugin_getinfo(PluginInfo *); */

float hnoise(float noisesize,
                   float x,
                   float y,
                   float z)
{
      return BLI_hnoise(noisesize, x, y, z);
}

float hnoisep(float noisesize,
                    float x,
                    float y,
                    float z)
{
      return BLI_hnoisep(noisesize, x, y, z);
}

float turbulence(float noisesize,
                         float x,
                         float y,
                         float z,
                         int depth)
{
      return BLI_turbulence(noisesize, x, y, z, depth);
}

float turbulence1(float noisesize,
                          float x,
                          float y,
                          float z,
                          int depth)
{
      return BLI_turbulence1(noisesize, x, y, z, depth);
}

/* -------------------------------------------------------------------------- */

      /* Stupid hack - force the inclusion of all of the
       * above functions in the binary by 'using' each one...
       * Otherwise they will not be imported from the archive
       * library on Unix. -zr
       */
int pluginapi_force_ref(void) 
{
      return (int) mallocN +
            (int) callocN +
            (int) freeN +
            (int) allocImBuf +
            (int) dupImBuf +
            (int) freeImBuf +
            (int) converttocmap +
            (int) saveiff +
            (int) loadiffmem +
            (int) loadifffile +
            (int) loadiffname +
            (int) testiffname +
            (int) onehalf +
            (int) onethird +
            (int) halflace +
            (int) half_x +
            (int) half_y +
            (int) double_x +
            (int) double_y +
            (int) double_fast_x +
            (int) double_fast_y +
            (int) ispic +
            (int) dit2 +
            (int) dit0 +
            (int) scaleImBuf +
            (int) scalefastImBuf +
            (int) scalefieldImBuf +
            (int) scalefastfieldImBuf +
            (int) hnoise +
            (int) hnoisep +
            (int) turbulence +
            (int) turbulence1 +
            (int) de_interlace +
            (int) interlace +
            (int) gamwarp +
            (int) rectop;
}

Generated by  Doxygen 1.6.0   Back to index