pane2dgray.c

Go to the documentation of this file.

/***************************************************************************
 *   stick2xyz - Can create and convert stick figure animations for CG.    *
 *   Copyright (C) 2021 by Kevin McBride <dolphindddd@aol.com>             *
 *                                                                         *
 *  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 3 of the License, or      *
 *  (at your option) any later version.                                    *
 *                                                                         *
 *  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, see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
 
 
#include "pane2dgraypriv.h"
 
 
#ifdef      DOXYGEN_BUILD
#include "pane2dgray.h"
#include "pane2dgray16.h"
#include "pane2drgb.h"
#include "pane2drgb16.h"
#else /* not DOXYGEN_BUILD */
 
static int modversion[] = 
      {STICK2XYZ_VER_MAJOR, STICK2XYZ_VER_MINOR, STICK2XYZ_VER_REVISION};
 
stick2xyz_print_ptr stick2xyz_lang_lib_pane2dgray = NULL;
 
/* The file descriptors we are outputting tty information to. */
static FILE * modttyout = NULL;
static FILE * modttyerr = NULL;
 
 
/* Pane2D General Module Info Functions */
stick2xyz_pctchar pane2dgray_name ( void )
{
      return stick2xyz_pane2dgray_modname();
}
 
stick2xyz_pctchar pane2dgray_desc ( void )
{
      return stick2xyz_pane2dgray_moddesc();
}
 
void pane2dgray_version ( int * dest )
{
      dest[0] = modversion[0];
      dest[1] = modversion[1];
      dest[2] = modversion[2];
}
 
int pane2dgray_type ( void )
{
#ifdef      UNICODE
#ifdef      DEBUG
      return STICK2XYZ_MODTYPE_PANE2D_UNICODE_DEBUG;
#else /* not DEBUG */
      return STICK2XYZ_MODTYPE_PANE2D_UNICODE;
#endif      /* not DEBUG */
#else /* not UNICODE */
#ifdef      DEBUG
      return STICK2XYZ_MODTYPE_PANE2D_DEBUG;
#else /* not DEBUG */
      return STICK2XYZ_MODTYPE_PANE2D;
#endif      /* not DEBUG */
#endif      /* not UNICODE */
}
 
void pane2dgray_set_tty ( void * fildescout, void * fildescerr )
{
      modttyout = (FILE *)fildescout;
      modttyerr = (FILE *)fildescerr;
}
 
int pane2dgray_get_bpp ( void )
{
      return 8;
}
 
FILE * pane2dgray_get_ttyout ( void )
{
      if ( modttyout == NULL )
            return stdout;
      else
            return modttyout;
}
 
FILE * pane2dgray_get_ttyerr ( void )
{
      if ( modttyerr == NULL )
            return stderr;
      else
            return modttyerr;
}
#endif      /* not DOXYGEN_BUILD */
 
 
#ifndef     STICK2XYZ_STATIC
/* Pane2D General Module Info Functions */
stick2xyz_pctchar mod_pane2d_name ( void )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_name();
      pane2drgb_name();
      pane2drgb16_name();
#endif      /* DOXYGEN_BUILD */
      return (stick2xyz_pctchar)pane2dgray_name();
}
 
stick2xyz_pctchar mod_pane2d_desc ( void )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_desc();
      pane2drgb_desc();
      pane2drgb16_desc();
#endif      /* DOXYGEN_BUILD */
      return (stick2xyz_pctchar)pane2dgray_desc();
}
 
void mod_pane2d_version ( int * dest )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_version(dest);
      pane2drgb_version(dest);
      pane2drgb16_version(dest);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_version(dest);
}
 
int mod_pane2d_type ( void )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_type();
      pane2drgb_type();
      pane2drgb16_type();
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_type();
}
 
void mod_pane2d_set_tty ( void * fildescout, void * fildescerr )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_set_tty(fildescout, fildescerr);
      pane2drgb_set_tty(fildescout, fildescerr);
      pane2drgb16_set_tty(fildescout, fildescerr);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_set_tty(fildescout, fildescerr);
}
 
 
int mod_pane2d_can_multithread ( void )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_can_multithread();
      pane2drgb_can_multithread();
      pane2drgb16_can_multithread();
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_can_multithread();
}
 
int mod_pane2d_is_multithreaded ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_is_multithreaded(pane);
      pane2drgb_is_multithreaded(pane);
      pane2drgb16_is_multithreaded(pane);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_is_multithreaded(pane);
}
 
 
int mod_pane2d_get_bpp ( void )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_get_bpp();
      pane2drgb_get_bpp();
      pane2drgb16_get_bpp();
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_get_bpp();
}
 
 
void mod_pane2d_getref ( pane2d_handle pane, int * refcount, int * refwaiting )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_getref(pane, refcount, refwaiting);
      pane2drgb_getref(pane, refcount, refwaiting);
      pane2drgb16_getref(pane, refcount, refwaiting);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_getref(pane, refcount, refwaiting);
}
 
int mod_pane2d_addref ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_addref(pane);
      pane2drgb_addref(pane);
      pane2drgb16_addref(pane);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_addref(pane);
}
 
int mod_pane2d_releaseref ( pane2d_handle pane, int asyncrelease, int shutdown )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_releaseref(pane, asyncrelease, shutdown);
      pane2drgb_releaseref(pane, asyncrelease, shutdown);
      pane2drgb16_releaseref(pane, asyncrelease, shutdown);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_releaseref(pane, asyncrelease, shutdown);
}
 
int mod_pane2d_isowner ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_isowner(pane);
      pane2drgb_isowner(pane);
      pane2drgb16_isowner(pane);
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_isowner(pane);
}
 
int mod_pane2d_candraw ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_candraw(pane);
      pane2drgb_candraw(pane);
      pane2drgb16_candraw(pane);
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_candraw(pane);
}
 
#if   defined(__WINDOWS__) | defined(DOXYGEN_BUILD)
DWORD mod_pane2d_getownerinfo_windows (
      pane2d_handle pane,
      LPHANDLE destvar
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_getownerinfo_windows(pane, destvar);
      pane2drgb_getownerinfo_windows(pane, destvar);
      pane2drgb16_getownerinfo_windows(pane, destvar);
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_getownerinfo_windows(pane, destvar);
}
 
 
BOOL mod_pane2d_getdrawaclinfo_windows(
      pane2d_handle pane,
      struct pane2d_drawacl * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_getdrawaclinfo_windows(pane, dest);
      pane2drgb_getdrawaclinfo_windows(pane, dest);
      pane2drgb16_getdrawaclinfo_windows(pane, dest);
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_getdrawaclinfo_windows(pane, dest);
}
 
BOOL mod_pane2d_freedrawaclinfo_windows(
      pane2d_handle pane,
      struct pane2d_drawacl * src
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_freedrawaclinfo_windows(pane, src);
      pane2drgb_freedrawaclinfo_windows(pane, src);
      pane2drgb16_freedrawaclinfo_windows(pane, src);
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_freedrawaclinfo_windows(pane, src);
}
#endif      /* defined(__WINDOWS__) | defined(DOXYGEN_BUILD) */
 
int mod_pane2d_waituntilowner ( pane2d_handle pane, int addref )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_waituntilowner(pane,addref);
      pane2drgb_waituntilowner(pane,addref);
      pane2drgb16_waituntilowner(pane,addref);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_waituntilowner(pane,addref);
}
 
int mod_pane2d_termwaituntilowner ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_termwaituntilowner(pane);
      pane2drgb_termwaituntilowner(pane);
      pane2drgb16_termwaituntilowner(pane);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_termwaituntilowner(pane);
}
 
#ifdef      DOXYGEN_BUILD
int mod_pane2d_changeaccesscontrol (
      pane2d_handle pane,
      void * hthread,
      int hthreadsize,
      uint32_t flags
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
      pane2drgb_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
      pane2drgb16_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
}
 
int mod_pane2d_changeowningthread (
      pane2d_handle pane,
      void * newthread,
      int addref
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_changeowningthread(pane, newthread, addref);
      pane2drgb_changeowningthread(pane, newthread, addref);
      pane2drgb16_changeowningthread(pane, newthread, addref);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_changeowningthread(pane, newthread, addref);
}
 
void * mod_pane2d_eventreleased ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_eventreleased(pane);
      pane2drgb_eventreleased(pane);
      pane2drgb16_eventreleased(pane);
#endif      /* DOXYGEN_BUILD */
 
      return pane2dgray_eventreleased(pane);
}
#else /* not DOXYGEN_BUILD */
#ifdef      __WINDOWS__
int mod_pane2d_changeaccesscontrol (
      pane2d_handle pane,
      PHANDLE hthread,
      int hthreadsize,
      uint32_t flags
)
{
      return pane2dgray_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
}
 
int mod_pane2d_changeowningthread (
      pane2d_handle pane,
      HANDLE newthread,
      int addref
)
{
      return pane2dgray_changeowningthread(pane, newthread, addref);
}
 
HANDLE mod_pane2d_eventreleased ( pane2d_handle pane )
{
      return pane2dgray_eventreleased(pane);
}
#else /* not __WINDOWS__ */
#ifdef      HAVE_THREADS_H
int mod_pane2d_changeaccesscontrol (
      pane2d_handle pane,
      thrd_t * hthread,
      int hthreadsize,
      uint32_t flags
)
{
      return pane2dgray_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
}
 
int mod_pane2d_changeowningthread (
      pane2d_handle pane,
      thrd_t newthread,
      int addref
)
{
      return pane2dgray_changeowningthread(pane, newthread, addref);
}
#else /* not HAVE_THREADS_H */
int mod_pane2d_changeaccesscontrol (
      pane2d_handle pane,
      void * hthread,
      int hthreadsize,
      uint32_t flags
)
{
      return pane2dgray_changeaccesscontrol(
            pane, hthread, hthreadsize, flags
      );
}
 
int mod_pane2d_changeowningthread (
      pane2d_handle pane,
      void * newthread,
      int addref
)
{
      return pane2dgray_changeowningthread(pane, newthread, addref);
}
#endif      /* not HAVE_THREADS_H */
 
#ifdef      HAVE_EVENTFD
int mod_pane2d_eventreleased ( pane2d_handle pane )
{
      return pane2dgray_eventreleased(pane);
}
#endif      /* HAVE_EVENTFD */
#endif      /* not __WINDOWS__ */
#endif      /* not DOXYGEN_BUILD */
 
 
pane2d_handle mod_pane2d_alloc ( int x, int y )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_alloc(x, y);
      pane2drgb_alloc(x, y);
      pane2drgb16_alloc(x, y);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_alloc(x, y);
}
 
pane2d_handle mod_pane2d_alloc_multithread (
      int x,
      int y,
      size_t maxthreads,
      uint32_t typesallowed
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_alloc_multithread(x, y, maxthreads, typesallowed);
      pane2drgb_alloc_multithread(x, y, maxthreads, typesallowed);
      pane2drgb16_alloc_multithread(x, y, maxthreads, typesallowed);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_alloc_multithread(x, y, maxthreads, typesallowed);
}
 
void mod_pane2d_clear ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_clear(pane);
      pane2drgb_clear(pane);
      pane2drgb16_clear(pane);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_clear(pane);
}
 
void mod_pane2d_free ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_free(pane);
      pane2drgb_free(pane);
      pane2drgb16_free(pane);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_free(pane);
}
 
 
uint32_t mod_pane2d_vertex_getopts ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_vertex_getopts(pane);
      pane2drgb_vertex_getopts(pane);
      pane2drgb16_vertex_getopts(pane);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_vertex_getopts(pane);
}
 
void mod_pane2d_vertex_setopts ( pane2d_handle pane, uint32_t newopts )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_vertex_setopts(pane, newopts);
      pane2drgb_vertex_setopts(pane, newopts);
      pane2drgb16_vertex_setopts(pane, newopts);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_vertex_setopts(pane, newopts);
}
 
int mod_pane2d_vertex_get (
      pane2d_handle pane,
      int elm,
      struct pane2d_vertex_elm * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_vertex_get(pane, elm, dest);
      pane2drgb_vertex_get(pane, elm, dest);
      pane2drgb16_vertex_get(pane, elm, dest);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_vertex_get(pane, elm, dest);
}
 
 
int mod_pane2d_vertex_get_v2 (
      pane2d_handle pane,
      int elm,
      struct pane2d_vertex_elm_v2 * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_vertex_get_v2(pane, elm, dest);
      pane2drgb_vertex_get_v2(pane, elm, dest);
      pane2drgb16_vertex_get_v2(pane, elm, dest);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_vertex_get_v2(pane, elm, dest);
}
 
 
uint64_t mod_pane2d_texture_add_gray (
      pane2d_handle pane,
      uint8_t gray,
      uint8_t alpha,
      pane2d_texture_handle * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_texture_add_gray(pane, gray, alpha, dest);
      pane2drgb_texture_add_gray(pane, gray, alpha, dest);
      pane2drgb16_texture_add_gray(pane, gray, alpha, dest);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_texture_add_gray(pane, gray, alpha, dest);
}
 
uint64_t mod_pane2d_texture_add_gray16 (
      pane2d_handle pane,
      uint16_t gray,
      uint16_t alpha,
      pane2d_texture_handle * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_texture_add_gray16(pane, gray, alpha, dest);
      pane2drgb_texture_add_gray16(pane, gray, alpha, dest);
      pane2drgb16_texture_add_gray16(pane, gray, alpha, dest);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_texture_add_gray16(pane, gray, alpha, dest);
}
 
uint64_t mod_pane2d_texture_add_rgb (
      pane2d_handle pane,
      uint8_t red,
      uint8_t green,
      uint8_t blue,
      uint8_t alpha,
      pane2d_texture_handle * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_texture_add_rgb(
            pane, red, green, blue, alpha, dest
      );
      pane2drgb_texture_add_rgb(
            pane, red, green, blue, alpha, dest
      );
      pane2drgb16_texture_add_rgb(
            pane, red, green, blue, alpha, dest
      );
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_texture_add_rgb(
            pane, red, green, blue, alpha, dest
      );
}
 
uint64_t mod_pane2d_texture_add_rgb16 (
      pane2d_handle pane,
      uint16_t red,
      uint16_t green,
      uint16_t blue,
      uint16_t alpha,
      pane2d_texture_handle * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_texture_add_rgb16(
            pane, red, green, blue, alpha, dest
      );
      pane2drgb_texture_add_rgb16(
            pane, red, green, blue, alpha, dest
      );
      pane2drgb16_texture_add_rgb16(
            pane, red, green, blue, alpha, dest
      );
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_texture_add_rgb16(
            pane, red, green, blue, alpha, dest
      );
}
 
int mod_pane2d_texture_enum (
      pane2d_handle pane,
      pane2d_texture_handle * dest,
      uint64_t number
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_texture_enum(pane, dest, number);
      pane2drgb_texture_enum(pane, dest, number);
      pane2drgb16_texture_enum(pane, dest, number);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_texture_enum(pane, dest, number);
}
 
void mod_pane2d_texture_clear ( pane2d_handle pane )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_texture_clear(pane);
      pane2drgb_texture_clear(pane);
      pane2drgb16_texture_clear(pane);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_texture_clear(pane);
}
 
uint32_t mod_pane2d_colortype ( void )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_colortype();
      pane2drgb_colortype();
      pane2drgb16_colortype();
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_colortype();
}
 
 
uint8_t ** mod_pane2d_dupdata ( pane2d_handle pane, int padding )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupdata(pane, padding);
      pane2drgb_dupdata(pane, padding);
      pane2drgb16_dupdata(pane, padding);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_dupdata(pane, padding);
}
 
uint8_t ** mod_pane2d_dupimage ( pane2d_handle pane, int padding )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupimage(pane, padding);
      pane2drgb_dupimage(pane, padding);
      pane2drgb16_dupimage(pane, padding);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_dupimage(pane, padding);
}
 
void mod_pane2d_freeimage ( pane2d_handle pane, uint8_t ** image )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_freeimage(pane, image);
      pane2drgb_freeimage(pane, image);
      pane2drgb16_freeimage(pane, image);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_freeimage(pane, image);
}
 
uint16_t ** mod_pane2d_dupimage16 ( pane2d_handle pane, int padding )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupimage16(pane, padding);
      pane2drgb_dupimage16(pane, padding);
      pane2drgb16_dupimage16(pane, padding);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_dupimage16(pane, padding);
}
 
void mod_pane2d_freeimage16 ( pane2d_handle pane, uint16_t ** image )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_freeimage16(pane, image);
      pane2drgb_freeimage16(pane, image);
      pane2drgb16_freeimage16(pane, image);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_freeimage16(pane, image);
}
 
uint8_t * mod_pane2d_dupdatap ( pane2d_handle pane, int padding )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupdatap(pane, padding);
      pane2drgb_dupdatap(pane, padding);
      pane2drgb16_dupdatap(pane, padding);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_dupdatap(pane, padding);
}
 
void mod_pane2d_freedatap ( pane2d_handle pane, uint8_t * image )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_freedatap(pane, image);
      pane2drgb_freedatap(pane, image);
      pane2drgb16_freedatap(pane, image);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_freedatap(pane, image);
}
 
uint16_t * mod_pane2d_dupdata16p ( pane2d_handle pane, int padding )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupdata16p(pane, padding);
      pane2drgb_dupdata16p(pane, padding);
      pane2drgb16_dupdata16p(pane, padding);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_dupdata16p(pane, padding);
}
 
void mod_pane2d_freedata16p ( pane2d_handle pane, uint16_t * image )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_freedata16p(pane, image);
      pane2drgb_freedata16p(pane, image);
      pane2drgb16_freedata16p(pane, image);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_freedata16p(pane, image);
}
 
void mod_pane2d_dupxy ( pane2d_handle pane, int * x, int * y )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupxy(pane, x, y);
      pane2drgb_dupxy(pane, x, y);
      pane2drgb16_dupxy(pane, x, y);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_dupxy(pane, x, y);
}
 
int mod_pane2d_dupfunc_getlist (
      uint32_t typerequested,
      struct pane2d_dupgen_funcs * dest
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_dupfunc_getlist(typerequested, dest);
      pane2drgb_dupfunc_getlist(typerequested, dest);
      pane2drgb16_dupfunc_getlist(typerequested, dest);
#endif      /* DOXYGEN_BUILD */
      return pane2dgray_dupfunc_getlist(typerequested, dest);
}
 
 
void mod_pane2d_drawpixel ( pane2d_handle pane, int x, int y )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawpixel(pane, x, y);
      pane2drgb_drawpixel(pane, x, y);
      pane2drgb16_drawpixel(pane, x, y);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawpixel(pane, x, y);
}
 
void mod_pane2d_drawline (
      pane2d_handle pane,
      int d,
      int x1,
      int y1,
      int x2,
      int y2
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawline(pane, d, x1, y1, x2, y2);
      pane2drgb_drawline(pane, d, x1, y1, x2, y2);
      pane2drgb16_drawline(pane, d, x1, y1, x2, y2);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawline(pane, d, x1, y1, x2, y2);
}
 
void mod_pane2d_drawcircle (
        pane2d_handle pane,
        int d,
        int x,
        int y,
        int r
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawcircle(pane, d, x, y, r);
      pane2drgb_drawcircle(pane, d, x, y, r);
      pane2drgb16_drawcircle(pane, d, x, y, r);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawcircle(pane, d, x, y, r);
}
 
void mod_pane2d_fillcircle (
        pane2d_handle pane,
        pane2d_texture_handle src,
        int x,
        int y,
        int r
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_fillcircle(pane, src, x, y, r);
      pane2drgb_fillcircle(pane, src, x, y, r);
      pane2drgb16_fillcircle(pane, src, x, y, r);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_fillcircle(pane, src, x, y, r);
}
 
void mod_pane2d_drawellipse (
        pane2d_handle pane,
        int d,
        int x,
        int y,
        int rx,
      int ry
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawellipse(pane, d, x, y, rx, ry);
      pane2drgb_drawellipse(pane, d, x, y, rx, ry);
      pane2drgb16_drawellipse(pane, d, x, y, rx, ry);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawellipse(pane, d, x, y, rx, ry);
}
 
void mod_pane2d_fillellipse (
        pane2d_handle pane,
        pane2d_texture_handle src,
        int x,
        int y,
        int rx,
      int ry
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_fillellipse(pane, src, x, y, rx, ry);
      pane2drgb_fillellipse(pane, src, x, y, rx, ry);
      pane2drgb16_fillellipse(pane, src, x, y, rx, ry);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_fillellipse(pane, src, x, y, rx, ry);
}
 
void mod_pane2d_drawrect (
        pane2d_handle pane,
        int d,
        int x1,
        int y1,
        int x2,
        int y2
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawrect(pane, d, x1, y1, x2, y2);
      pane2drgb_drawrect(pane, d, x1, y1, x2, y2);
      pane2drgb16_drawrect(pane, d, x1, y1, x2, y2);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawrect(pane, d, x1, y1, x2, y2);
}
 
void mod_pane2d_fillrect (
      pane2d_handle pane,
      pane2d_texture_handle src,
      int x1,
      int y1,
      int x2,
      int y2
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_fillrect(pane, src, x1, y1, x2, y2);
      pane2drgb_fillrect(pane, src, x1, y1, x2, y2);
      pane2drgb16_fillrect(pane, src, x1, y1, x2, y2);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_fillrect(pane, src, x1, y1, x2, y2);
}
 
void mod_pane2d_drawsquare (
        pane2d_handle pane,
        int d,
        int l,
        int x1,
        int y1
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawsquare(pane, d, l, x1, y1);
      pane2drgb_drawsquare(pane, d, l, x1, y1);
      pane2drgb16_drawsquare(pane, d, l, x1, y1);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawsquare(pane, d, l, x1, y1);
}
 
void mod_pane2d_fillsquare (
        pane2d_handle pane,
        pane2d_texture_handle src,
        int l,
        int x1,
        int y1
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_fillsquare(pane, src, l, x1, y1);
      pane2drgb_fillsquare(pane, src, l, x1, y1);
      pane2drgb16_fillsquare(pane, src, l, x1, y1);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_fillsquare(pane, src, l, x1, y1);
}
 
void mod_pane2d_drawtriangle (
        pane2d_handle pane,
        int d,
        int x1,
        int y1,
        int x2,
        int y2,
        int x3,
        int y3
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawtriangle(pane, d, x1, y1, x2, y2, x3, y3);
      pane2drgb_drawtriangle(pane, d, x1, y1, x2, y2, x3, y3);
      pane2drgb16_drawtriangle(pane, d, x1, y1, x2, y2, x3, y3);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawtriangle(pane, d, x1, y1, x2, y2, x3, y3);
}
 
void mod_pane2d_filltriangle (
      pane2d_handle pane,
      pane2d_texture_handle src,
      int x1, 
      int y1,
      int x2,
      int y2,
      int x3,
      int y3
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_filltriangle(pane, src,
                            x1, y1, x2, y2, x3, y3);
      pane2drgb_filltriangle(pane, src,
                            x1, y1, x2, y2, x3, y3);
      pane2drgb16_filltriangle(pane, src,
                            x1, y1, x2, y2, x3, y3);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_filltriangle(pane, src,
                            x1, y1, x2, y2, x3, y3);
}
 
void mod_pane2d_drawrighttriangle (
      pane2d_handle pane,
      int d,
      int x1,
      int y1,
      int x2,
      int y2,
      int b
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawrighttriangle(pane, d, x1, y1, x2, y2, b);
      pane2drgb_drawrighttriangle(pane, d, x1, y1, x2, y2, b);
      pane2drgb16_drawrighttriangle(pane, d, x1, y1, x2, y2, b);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawrighttriangle(pane, d, x1, y1, x2, y2, b);
}
 
void mod_pane2d_fillrighttriangle (
      pane2d_handle pane,
      pane2d_texture_handle src,
      int x1,
      int y1,
      int x2,
      int y2,
      int b
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_fillrighttriangle(pane, src, x1, y1, x2, y2, b);
      pane2drgb_fillrighttriangle(pane, src, x1, y1, x2, y2, b);
      pane2drgb16_fillrighttriangle(pane, src, x1, y1, x2, y2, b);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_fillrighttriangle(pane, src, x1, y1, x2, y2, b);
}
 
void mod_pane2d_drawtworighttriangles (
      pane2d_handle pane,
      int d,
      int x1,
      int y1,
      int x2,
      int y2
)
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_drawtworighttriangles(pane, d, x1, y1, x2, y2);
      pane2drgb_drawtworighttriangles(pane, d, x1, y1, x2, y2);
      pane2drgb16_drawtworighttriangles(pane, d, x1, y1, x2, y2);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_drawtworighttriangles(pane, d, x1, y1, x2, y2);
}
 
#ifdef      DEBUG
void mod_pane2d_print_segment ( pane2d_handle pane, int use_rgb )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_print_segment(pane, use_rgb);
      pane2drgb_print_segment(pane, use_rgb);
      pane2drgb16_print_segment(pane, use_rgb);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_print_segment(pane, use_rgb);
}
#endif      /* DEBUG */
 
#ifndef     STICK2XYZ_NO_MODLANGPACKS
#ifndef     DOXYGEN_BUILD
void pane2dgray_lang ( stick2xyz_print_ptr newval )
{
      stick2xyz_lang_lib_pane2dgray = newval;
}
#endif      /* not DOXYGEN_BUILD */
 
void mod_pane2d_lang ( stick2xyz_print_ptr newval )
{
#ifdef      DOXYGEN_BUILD
      pane2dgray16_lang(newval);
      pane2drgb_lang(newval);
      pane2drgb16_lang(newval);
#endif      /* DOXYGEN_BUILD */
      pane2dgray_lang(newval);
}
#endif      /* not STICK2XYZ_NO_MODLANGPACKS */
 
 
#ifdef      DOXYGEN_BUILD
int mod_pane2d_init ( int multithread )
{
      return 1;
}
 
int mod_pane2d_release ( void )
{
      return 0;
}
 
int mod_pane2d_sigterm ( pane2d_sigterm_ready func, int modnumber )
{
      return 1;
}
#endif /* DOXYGEN_BUILD */
 
 
#else /* STICK2XYZ_STATIC */
void pane2dgray_funcptrs_setup ( struct pane2d_funcptrs * ptr )
{
      ptr->pane2d_funcptrs_name = &pane2dgray_name;
      ptr->pane2d_funcptrs_desc = &pane2dgray_desc;
      ptr->pane2d_funcptrs_version = &pane2dgray_version;
      ptr->pane2d_funcptrs_type = &pane2dgray_type;
      ptr->pane2d_funcptrs_set_tty = &pane2dgray_set_tty;
 
      ptr->pane2d_funcptrs_init = NULL;
      ptr->pane2d_funcptrs_release = NULL;
      ptr->pane2d_funcptrs_sigterm = NULL;
 
      ptr->pane2d_funcptrs_can_multithread = &pane2dgray_can_multithread;
      ptr->pane2d_funcptrs_is_multithreaded = &pane2dgray_is_multithreaded;
 
      ptr->pane2d_funcptrs_get_bpp = &pane2dgray_get_bpp;
 
      ptr->pane2d_funcptrs_getref = &pane2dgray_getref;
      ptr->pane2d_funcptrs_addref = &pane2dgray_addref;
      ptr->pane2d_funcptrs_releaseref = &pane2dgray_releaseref;
      ptr->pane2d_funcptrs_isowner = &pane2dgray_isowner;
      ptr->pane2d_funcptrs_candraw = &pane2dgray_candraw;
      ptr->pane2d_funcptrs_waituntilowner = &pane2dgray_waituntilowner;
      ptr->pane2d_funcptrs_termwaituntilowner = &pane2dgray_termwaituntilowner;
      ptr->pane2d_funcptrs_changeaccesscontrol = &pane2dgray_changeaccesscontrol;
      ptr->pane2d_funcptrs_changeowningthread = &pane2dgray_changeowningthread;
#ifdef      HAVE_EVENTFD
      ptr->pane2d_funcptrs_eventreleased = &pane2dgray_eventreleased;
#else /* not HAVE_EVENTFD */
      ptr->pane2d_funcptrs_eventreleased = NULL;
#endif      /* not HAVE_EVENTFD */
 
      ptr->pane2d_funcptrs_alloc = &pane2dgray_alloc;
      ptr->pane2d_funcptrs_alloc_multithread = &pane2dgray_alloc_multithread;
      ptr->pane2d_funcptrs_clear = &pane2dgray_clear;
      ptr->pane2d_funcptrs_free = &pane2dgray_free;
 
      ptr->pane2d_funcptrs_getopts = &pane2dgray_vertex_getopts;
      ptr->pane2d_funcptrs_setopts = &pane2dgray_vertex_setopts;
      ptr->pane2d_funcptrs_vertex_get = &pane2dgray_vertex_get;
      ptr->pane2d_funcptrs_vertex_get_v2 = &pane2dgray_vertex_get_v2;
 
      ptr->pane2d_funcptrs_texture_add_gray =
            &pane2dgray_texture_add_gray;
      ptr->pane2d_funcptrs_texture_add_gray16 =
            &pane2dgray_texture_add_gray16;
      ptr->pane2d_funcptrs_texture_add_rgb =
            &pane2dgray_texture_add_rgb;
      ptr->pane2d_funcptrs_texture_add_rgb16 =
            &pane2dgray_texture_add_rgb16;
      ptr->pane2d_funcptrs_texture_enum = &pane2dgray_texture_enum;
      ptr->pane2d_funcptrs_texture_clear = &pane2dgray_texture_clear;
      ptr->pane2d_funcptrs_colortype = &pane2dgray_colortype;
 
      ptr->pane2d_funcptrs_dupdata = &pane2dgray_dupdata;
      ptr->pane2d_funcptrs_dupimage = &pane2dgray_dupimage;
      ptr->pane2d_funcptrs_freeimage = &pane2dgray_freeimage;
      ptr->pane2d_funcptrs_dupimage16 = &pane2dgray_dupimage16;
      ptr->pane2d_funcptrs_freeimage16 = &pane2dgray_freeimage16;
      ptr->pane2d_funcptrs_dupdatap = &pane2dgray_dupdatap;
      ptr->pane2d_funcptrs_freedatap = &pane2dgray_freedatap;
      ptr->pane2d_funcptrs_dupdata16p = &pane2dgray_dupdata16p;
      ptr->pane2d_funcptrs_freedata16p = &pane2dgray_freedata16p;
      ptr->pane2d_funcptrs_dupxy = &pane2dgray_dupxy;
      ptr->pane2d_funcptrs_dupfunc_getlist = &pane2dgray_dupfunc_getlist;
 
      ptr->pane2d_funcptrs_drawpixel = &pane2dgray_drawpixel;
      ptr->pane2d_funcptrs_drawline = &pane2dgray_drawline;
 
      ptr->pane2d_funcptrs_drawcircle = &pane2dgray_drawcircle;
      ptr->pane2d_funcptrs_fillcircle = &pane2dgray_fillcircle;
      ptr->pane2d_funcptrs_drawellipse = &pane2dgray_drawellipse;
      ptr->pane2d_funcptrs_fillellipse = &pane2dgray_fillellipse;
 
      ptr->pane2d_funcptrs_drawrect = &pane2dgray_drawrect;
      ptr->pane2d_funcptrs_fillrect = &pane2dgray_fillrect;
      ptr->pane2d_funcptrs_drawsquare = &pane2dgray_drawsquare;
      ptr->pane2d_funcptrs_fillsquare = &pane2dgray_fillsquare;
 
      ptr->pane2d_funcptrs_drawtriangle = &pane2dgray_drawtriangle;
      ptr->pane2d_funcptrs_filltriangle = &pane2dgray_filltriangle;
      ptr->pane2d_funcptrs_drawrighttriangle =
            &pane2dgray_drawrighttriangle;
      ptr->pane2d_funcptrs_fillrighttriangle =
            &pane2dgray_fillrighttriangle;
 
#ifdef      DEBUG
      ptr->pane2d_funcptrs_print_segment =
            &pane2dgray_print_segment;
#else /* not DEBUG */
      ptr->pane2d_funcptrs_print_segment = NULL;
#endif      /* not DEBUG */
}
#endif      /* STICK2XYZ_STATIC */