forked from s444417/ProjektAI
865 lines
28 KiB
C
865 lines
28 KiB
C
/*
|
|
pygame - Python Game Library
|
|
Copyright (C) 2000-2001 Pete Shinners
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; if not, write to the Free
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
Pete Shinners
|
|
pete@shinners.org
|
|
*/
|
|
|
|
#ifndef _PYGAME_H
|
|
#define _PYGAME_H
|
|
|
|
/** This header file includes all the definitions for the
|
|
** base pygame extensions. This header only requires
|
|
** SDL and Python includes. The reason for functions
|
|
** prototyped with #define's is to allow for maximum
|
|
** python portability. It also uses python as the
|
|
** runtime linker, which allows for late binding. For more
|
|
** information on this style of development, read the Python
|
|
** docs on this subject.
|
|
** http://www.python.org/doc/current/ext/using-cobjects.html
|
|
**
|
|
** If using this to build your own derived extensions,
|
|
** you'll see that the functions available here are mainly
|
|
** used to help convert between python objects and SDL objects.
|
|
** Since this library doesn't add a lot of functionality to
|
|
** the SDL libarary, it doesn't need to offer a lot either.
|
|
**
|
|
** When initializing your extension module, you must manually
|
|
** import the modules you want to use. (this is the part about
|
|
** using python as the runtime linker). Each module has its
|
|
** own import_xxx() routine. You need to perform this import
|
|
** after you have initialized your own module, and before
|
|
** you call any routines from that module. Since every module
|
|
** in pygame does this, there are plenty of examples.
|
|
**
|
|
** The base module does include some useful conversion routines
|
|
** that you are free to use in your own extension.
|
|
**
|
|
** When making changes, it is very important to keep the
|
|
** FIRSTSLOT and NUMSLOT constants up to date for each
|
|
** section. Also be sure not to overlap any of the slots.
|
|
** When you do make a mistake with this, it will result
|
|
** is a dereferenced NULL pointer that is easier to diagnose
|
|
** than it could be :]
|
|
**/
|
|
#if defined(HAVE_SNPRINTF) /* defined in python.h (pyerrors.h) and SDL.h \
|
|
(SDL_config.h) */
|
|
#undef HAVE_SNPRINTF /* remove GCC redefine warning */
|
|
#endif
|
|
|
|
// This must be before all else
|
|
#if defined(__SYMBIAN32__) && defined(OPENC)
|
|
#include <sys/types.h>
|
|
|
|
#if defined(__WINS__)
|
|
void *
|
|
_alloca(size_t size);
|
|
#define alloca _alloca
|
|
#endif
|
|
#endif
|
|
|
|
#define PG_STRINGIZE_HELPER(x) #x
|
|
#define PG_STRINGIZE(x) PG_STRINGIZE_HELPER(x)
|
|
#define PG_WARN(desc) message(__FILE__ "(" PG_STRINGIZE(__LINE__) "): WARNING: " #desc)
|
|
|
|
/* This is unconditionally defined in Python.h */
|
|
#if defined(_POSIX_C_SOURCE)
|
|
#undef _POSIX_C_SOURCE
|
|
#endif
|
|
|
|
#include <Python.h>
|
|
|
|
/* the version macros are defined since version 1.9.5 */
|
|
#define PG_MAJOR_VERSION 1
|
|
#define PG_MINOR_VERSION 9
|
|
#define PG_PATCH_VERSION 6
|
|
#define PG_VERSIONNUM(MAJOR, MINOR, PATCH) (1000*(MAJOR) + 100*(MINOR) + (PATCH))
|
|
#define PG_VERSION_ATLEAST(MAJOR, MINOR, PATCH) \
|
|
(PG_VERSIONNUM(PG_MAJOR_VERSION, PG_MINOR_VERSION, PG_PATCH_VERSION) >= \
|
|
PG_VERSIONNUM(MAJOR, MINOR, PATCH))
|
|
|
|
/* Cobjects vanish in Python 3.2; so we will code as though we use capsules */
|
|
#if defined(Py_CAPSULE_H)
|
|
#define PG_HAVE_CAPSULE 1
|
|
#else
|
|
#define PG_HAVE_CAPSULE 0
|
|
#endif
|
|
#if defined(Py_COBJECT_H)
|
|
#define PG_HAVE_COBJECT 1
|
|
#else
|
|
#define PG_HAVE_COBJECT 0
|
|
#endif
|
|
#if !PG_HAVE_CAPSULE
|
|
#define PyCapsule_New(ptr, n, dfn) PyCObject_FromVoidPtr(ptr, dfn)
|
|
#define PyCapsule_GetPointer(obj, n) PyCObject_AsVoidPtr(obj)
|
|
#define PyCapsule_CheckExact(obj) PyCObject_Check(obj)
|
|
#endif
|
|
|
|
/* Pygame uses Py_buffer (PEP 3118) to exchange array information internally;
|
|
* define here as needed.
|
|
*/
|
|
#if !defined(PyBUF_SIMPLE)
|
|
typedef struct bufferinfo {
|
|
void *buf;
|
|
PyObject *obj;
|
|
Py_ssize_t len;
|
|
Py_ssize_t itemsize;
|
|
int readonly;
|
|
int ndim;
|
|
char *format;
|
|
Py_ssize_t *shape;
|
|
Py_ssize_t *strides;
|
|
Py_ssize_t *suboffsets;
|
|
void *internal;
|
|
} Py_buffer;
|
|
|
|
/* Flags for getting buffers */
|
|
#define PyBUF_SIMPLE 0
|
|
#define PyBUF_WRITABLE 0x0001
|
|
/* we used to include an E, backwards compatible alias */
|
|
#define PyBUF_WRITEABLE PyBUF_WRITABLE
|
|
#define PyBUF_FORMAT 0x0004
|
|
#define PyBUF_ND 0x0008
|
|
#define PyBUF_STRIDES (0x0010 | PyBUF_ND)
|
|
#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
|
|
#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
|
|
#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
|
|
#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
|
|
|
|
#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)
|
|
#define PyBUF_CONTIG_RO (PyBUF_ND)
|
|
|
|
#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)
|
|
#define PyBUF_STRIDED_RO (PyBUF_STRIDES)
|
|
|
|
#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)
|
|
#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
|
|
|
|
#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)
|
|
#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
|
|
|
|
#define PyBUF_READ 0x100
|
|
#define PyBUF_WRITE 0x200
|
|
#define PyBUF_SHADOW 0x400
|
|
|
|
typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
|
|
typedef void (*releasebufferproc)(Py_buffer *);
|
|
#endif /* #if !defined(PyBUF_SIMPLE) */
|
|
|
|
/* Flag indicating a pg_buffer; used for assertions within callbacks */
|
|
#ifndef NDEBUG
|
|
#define PyBUF_PYGAME 0x4000
|
|
#endif
|
|
|
|
#define PyBUF_HAS_FLAG(f, F) (((f) & (F)) == (F))
|
|
|
|
/* Array information exchange struct C type; inherits from Py_buffer
|
|
*
|
|
* Pygame uses its own Py_buffer derived C struct as an internal representation
|
|
* of an imported array buffer. The extended Py_buffer allows for a
|
|
* per-instance release callback,
|
|
*/
|
|
typedef void (*pybuffer_releaseproc)(Py_buffer *);
|
|
|
|
typedef struct pg_bufferinfo_s {
|
|
Py_buffer view;
|
|
PyObject *consumer; /* Input: Borrowed reference */
|
|
pybuffer_releaseproc release_buffer;
|
|
} pg_buffer;
|
|
|
|
/* Operating system specific adjustments
|
|
*/
|
|
// No signal()
|
|
#if defined(__SYMBIAN32__) && defined(HAVE_SIGNAL_H)
|
|
#undef HAVE_SIGNAL_H
|
|
#endif
|
|
|
|
#if defined(HAVE_SNPRINTF)
|
|
#undef HAVE_SNPRINTF
|
|
#endif
|
|
|
|
#ifdef MS_WIN32 /*Python gives us MS_WIN32, SDL needs just WIN32*/
|
|
#ifndef WIN32
|
|
#define WIN32
|
|
#endif
|
|
#endif
|
|
|
|
/// Prefix when initializing module
|
|
#define MODPREFIX ""
|
|
/// Prefix when importing module
|
|
#define IMPPREFIX "pygame."
|
|
|
|
#ifdef __SYMBIAN32__
|
|
#undef MODPREFIX
|
|
#undef IMPPREFIX
|
|
// On Symbian there is no pygame package. The extensions are built-in or in
|
|
// sys\bin.
|
|
#define MODPREFIX "pygame_"
|
|
#define IMPPREFIX "pygame_"
|
|
#endif
|
|
|
|
#include <SDL.h>
|
|
|
|
/* Pygame's SDL version macros:
|
|
* IS_SDLv1 is 1 if SDL 1.x.x, 0 otherwise
|
|
* IS_SDLv2 is 1 if at least SDL 2.0.0, 0 otherwise
|
|
*/
|
|
#if (SDL_VERSION_ATLEAST(2, 0, 0))
|
|
#define IS_SDLv1 0
|
|
#define IS_SDLv2 1
|
|
#else
|
|
#define IS_SDLv1 1
|
|
#define IS_SDLv2 0
|
|
#endif
|
|
|
|
/*#if IS_SDLv1 && PG_MAJOR_VERSION >= 2
|
|
#error pygame 2 requires SDL 2
|
|
#endif*/
|
|
|
|
#if IS_SDLv2
|
|
/* SDL 1.2 constants removed from SDL 2 */
|
|
typedef enum {
|
|
SDL_HWSURFACE = 0,
|
|
SDL_RESIZABLE = SDL_WINDOW_RESIZABLE,
|
|
SDL_ASYNCBLIT = 0,
|
|
SDL_OPENGL = SDL_WINDOW_OPENGL,
|
|
SDL_OPENGLBLIT = 0,
|
|
SDL_ANYFORMAT = 0,
|
|
SDL_HWPALETTE = 0,
|
|
SDL_DOUBLEBUF = 0,
|
|
SDL_FULLSCREEN = SDL_WINDOW_FULLSCREEN,
|
|
SDL_HWACCEL = 0,
|
|
SDL_SRCCOLORKEY = 0,
|
|
SDL_RLEACCELOK = 0,
|
|
SDL_SRCALPHA = 0,
|
|
SDL_NOFRAME = SDL_WINDOW_BORDERLESS,
|
|
SDL_GL_SWAP_CONTROL = 0,
|
|
TIMER_RESOLUTION = 0
|
|
} PygameVideoFlags;
|
|
|
|
/* the wheel button constants were removed from SDL 2 */
|
|
typedef enum {
|
|
PGM_BUTTON_LEFT = SDL_BUTTON_LEFT,
|
|
PGM_BUTTON_RIGHT = SDL_BUTTON_RIGHT,
|
|
PGM_BUTTON_MIDDLE = SDL_BUTTON_MIDDLE,
|
|
PGM_BUTTON_WHEELUP = 4,
|
|
PGM_BUTTON_WHEELDOWN = 5,
|
|
PGM_BUTTON_X1 = SDL_BUTTON_X1 + 2,
|
|
PGM_BUTTON_X2 = SDL_BUTTON_X2 + 2,
|
|
PGM_BUTTON_KEEP = 0x80
|
|
} PygameMouseFlags;
|
|
|
|
typedef enum {
|
|
SDL_NOEVENT = 0,
|
|
/* SDL 1.2 allowed for 8 user defined events. */
|
|
SDL_NUMEVENTS = SDL_USEREVENT + 8,
|
|
SDL_ACTIVEEVENT = SDL_NUMEVENTS,
|
|
PGE_EVENTBEGIN = SDL_NUMEVENTS,
|
|
SDL_VIDEORESIZE,
|
|
SDL_VIDEOEXPOSE,
|
|
PGE_KEYREPEAT,
|
|
PGE_EVENTEND
|
|
} PygameEventCode;
|
|
|
|
#define PGE_NUMEVENTS (PGE_EVENTEND - PGE_EVENTBEGIN)
|
|
|
|
typedef enum {
|
|
SDL_APPFOCUSMOUSE,
|
|
SDL_APPINPUTFOCUS,
|
|
SDL_APPACTIVE
|
|
} PygameAppCode;
|
|
|
|
/* Surface flags: based on SDL 1.2 flags */
|
|
typedef enum {
|
|
PGS_SWSURFACE = 0x00000000,
|
|
PGS_HWSURFACE = 0x00000001,
|
|
PGS_ASYNCBLIT = 0x00000004,
|
|
|
|
PGS_ANYFORMAT = 0x10000000,
|
|
PGS_HWPALETTE = 0x20000000,
|
|
PGS_DOUBLEBUF = 0x40000000,
|
|
PGS_FULLSCREEN = 0x80000000,
|
|
PGS_OPENGL = 0x00000002,
|
|
PGS_OPENGLBLIT = 0x0000000A,
|
|
PGS_RESIZABLE = 0x00000010,
|
|
PGS_NOFRAME = 0x00000020,
|
|
PGS_SHOWN = 0x00000040, /* Added from SDL 2 */
|
|
PGS_HIDDEN = 0x00000080, /* Added from SDL 2 */
|
|
|
|
PGS_HWACCEL = 0x00000100,
|
|
PGS_SRCCOLORKEY = 0x00001000,
|
|
PGS_RLEACCELOK = 0x00002000,
|
|
PGS_RLEACCEL = 0x00004000,
|
|
PGS_SRCALPHA = 0x00010000,
|
|
PGS_PREALLOC = 0x01000000
|
|
} PygameSurfaceFlags;
|
|
|
|
typedef struct {
|
|
Uint32 hw_available:1;
|
|
Uint32 wm_available:1;
|
|
Uint32 blit_hw:1;
|
|
Uint32 blit_hw_CC:1;
|
|
Uint32 blit_hw_A:1;
|
|
Uint32 blit_sw:1;
|
|
Uint32 blit_sw_CC:1;
|
|
Uint32 blit_sw_A:1;
|
|
Uint32 blit_fill:1;
|
|
Uint32 video_mem;
|
|
SDL_PixelFormat *vfmt;
|
|
SDL_PixelFormat vfmt_data;
|
|
int current_w;
|
|
int current_h;
|
|
} pg_VideoInfo;
|
|
|
|
#endif /* IS_SDLv2 */
|
|
/* macros used throughout the source */
|
|
#define RAISE(x, y) (PyErr_SetString((x), (y)), (PyObject *)NULL)
|
|
|
|
#ifdef WITH_THREAD
|
|
#define PG_CHECK_THREADS() (1)
|
|
#else /* ~WITH_THREAD */
|
|
#define PG_CHECK_THREADS() \
|
|
(RAISE(PyExc_NotImplementedError, \
|
|
"Python built without thread support"))
|
|
#endif /* ~WITH_THREAD */
|
|
|
|
#define PyType_Init(x) (((x).ob_type) = &PyType_Type)
|
|
#define PYGAMEAPI_LOCAL_ENTRY "_PYGAME_C_API"
|
|
|
|
#ifndef MIN
|
|
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
#endif
|
|
|
|
#ifndef MAX
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
#endif
|
|
|
|
#ifndef ABS
|
|
#define ABS(a) (((a) < 0) ? -(a) : (a))
|
|
#endif
|
|
|
|
/* test sdl initializations */
|
|
#define VIDEO_INIT_CHECK() \
|
|
if (!SDL_WasInit(SDL_INIT_VIDEO)) \
|
|
return RAISE(pgExc_SDLError, "video system not initialized")
|
|
|
|
#define CDROM_INIT_CHECK() \
|
|
if (!SDL_WasInit(SDL_INIT_CDROM)) \
|
|
return RAISE(pgExc_SDLError, "cdrom system not initialized")
|
|
|
|
#define JOYSTICK_INIT_CHECK() \
|
|
if (!SDL_WasInit(SDL_INIT_JOYSTICK)) \
|
|
return RAISE(pgExc_SDLError, "joystick system not initialized")
|
|
|
|
/* BASE */
|
|
#define VIEW_CONTIGUOUS 1
|
|
#define VIEW_C_ORDER 2
|
|
#define VIEW_F_ORDER 4
|
|
|
|
#define PYGAMEAPI_BASE_FIRSTSLOT 0
|
|
#if IS_SDLv1
|
|
#define PYGAMEAPI_BASE_NUMSLOTS 19
|
|
#else /* IS_SDLv2 */
|
|
#define PYGAMEAPI_BASE_NUMSLOTS 23
|
|
#endif /* IS_SDLv2 */
|
|
#ifndef PYGAMEAPI_BASE_INTERNAL
|
|
#define pgExc_SDLError ((PyObject *)PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT])
|
|
|
|
#define pg_RegisterQuit \
|
|
(*(void (*)(void (*)(void)))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 1])
|
|
|
|
#define pg_IntFromObj \
|
|
(*(int (*)(PyObject *, int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 2])
|
|
|
|
#define pg_IntFromObjIndex \
|
|
(*(int (*)(PyObject *, int, \
|
|
int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 3])
|
|
|
|
#define pg_TwoIntsFromObj \
|
|
(*(int (*)(PyObject *, int *, \
|
|
int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 4])
|
|
|
|
#define pg_FloatFromObj \
|
|
(*(int (*)(PyObject *, float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 5])
|
|
|
|
#define pg_FloatFromObjIndex \
|
|
(*(int (*)(PyObject *, int, \
|
|
float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 6])
|
|
|
|
#define pg_TwoFloatsFromObj \
|
|
(*(int (*)(PyObject *, float *, \
|
|
float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 7])
|
|
|
|
#define pg_UintFromObj \
|
|
(*(int (*)(PyObject *, \
|
|
Uint32 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 8])
|
|
|
|
#define pg_UintFromObjIndex \
|
|
(*(int (*)(PyObject *, int, \
|
|
Uint32 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 9])
|
|
|
|
#define pgVideo_AutoQuit \
|
|
(*(void (*)(void))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 10])
|
|
|
|
#define pgVideo_AutoInit \
|
|
(*(int (*)(void))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 11])
|
|
|
|
#define pg_RGBAFromObj \
|
|
(*(int (*)(PyObject *, \
|
|
Uint8 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 12])
|
|
|
|
#define pgBuffer_AsArrayInterface \
|
|
(*(PyObject * (*)(Py_buffer *)) \
|
|
PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 13])
|
|
|
|
#define pgBuffer_AsArrayStruct \
|
|
(*(PyObject * (*)(Py_buffer *)) \
|
|
PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 14])
|
|
|
|
#define pgObject_GetBuffer \
|
|
(*(int (*)(PyObject *, pg_buffer *, \
|
|
int))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 15])
|
|
|
|
#define pgBuffer_Release \
|
|
(*(void (*)(pg_buffer *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 16])
|
|
|
|
#define pgDict_AsBuffer \
|
|
(*(int (*)(pg_buffer *, PyObject *, \
|
|
int))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 17])
|
|
|
|
#define pgExc_BufferError \
|
|
((PyObject *)PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 18])
|
|
|
|
#if IS_SDLv2
|
|
#define pg_GetDefaultWindow \
|
|
(*(SDL_Window * (*)(void)) PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 19])
|
|
|
|
#define pg_SetDefaultWindow \
|
|
(*(void (*)(SDL_Window *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 20])
|
|
|
|
#define pg_GetDefaultWindowSurface \
|
|
(*(PyObject * (*)(void)) PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 21])
|
|
|
|
#define pg_SetDefaultWindowSurface \
|
|
(*(void (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 22])
|
|
|
|
#endif /* IS_SDLv2 */
|
|
|
|
#define import_pygame_base() IMPORT_PYGAME_MODULE(base, BASE)
|
|
#endif
|
|
|
|
/* RECT */
|
|
#define PYGAMEAPI_RECT_FIRSTSLOT \
|
|
(PYGAMEAPI_BASE_FIRSTSLOT + PYGAMEAPI_BASE_NUMSLOTS)
|
|
#define PYGAMEAPI_RECT_NUMSLOTS 4
|
|
|
|
#if IS_SDLv1
|
|
typedef struct {
|
|
int x, y;
|
|
int w, h;
|
|
} GAME_Rect;
|
|
#else
|
|
typedef SDL_Rect GAME_Rect;
|
|
#endif
|
|
|
|
typedef struct {
|
|
PyObject_HEAD GAME_Rect r;
|
|
PyObject *weakreflist;
|
|
} pgRectObject;
|
|
|
|
#define pgRect_AsRect(x) (((pgRectObject *)x)->r)
|
|
#ifndef PYGAMEAPI_RECT_INTERNAL
|
|
#define pgRect_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 0])
|
|
#define pgRect_Type \
|
|
(*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 0])
|
|
#define pgRect_New \
|
|
(*(PyObject * (*)(SDL_Rect *)) PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 1])
|
|
#define pgRect_New4 \
|
|
(*(PyObject * (*)(int, int, int, int)) \
|
|
PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 2])
|
|
#define pgRect_FromObject \
|
|
(*(GAME_Rect * (*)(PyObject *, GAME_Rect *)) \
|
|
PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 3])
|
|
|
|
#define import_pygame_rect() IMPORT_PYGAME_MODULE(rect, RECT)
|
|
#endif
|
|
|
|
/* CDROM */
|
|
#define PYGAMEAPI_CDROM_FIRSTSLOT \
|
|
(PYGAMEAPI_RECT_FIRSTSLOT + PYGAMEAPI_RECT_NUMSLOTS)
|
|
#define PYGAMEAPI_CDROM_NUMSLOTS 2
|
|
|
|
typedef struct {
|
|
PyObject_HEAD int id;
|
|
} pgCDObject;
|
|
|
|
#define pgCD_AsID(x) (((pgCDObject *)x)->id)
|
|
#ifndef PYGAMEAPI_CDROM_INTERNAL
|
|
#define pgCD_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 0])
|
|
#define pgCD_Type \
|
|
(*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 0])
|
|
#define pgCD_New \
|
|
(*(PyObject * (*)(int)) PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 1])
|
|
|
|
#define import_pygame_cd() IMPORT_PYGAME_MODULE(cdrom, CDROM)
|
|
#endif
|
|
|
|
/* JOYSTICK */
|
|
#define PYGAMEAPI_JOYSTICK_FIRSTSLOT \
|
|
(PYGAMEAPI_CDROM_FIRSTSLOT + PYGAMEAPI_CDROM_NUMSLOTS)
|
|
#define PYGAMEAPI_JOYSTICK_NUMSLOTS 2
|
|
|
|
typedef struct {
|
|
PyObject_HEAD int id;
|
|
} pgJoystickObject;
|
|
|
|
#define pgJoystick_AsID(x) (((pgJoystickObject *)x)->id)
|
|
|
|
#ifndef PYGAMEAPI_JOYSTICK_INTERNAL
|
|
#define pgJoystick_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 0])
|
|
|
|
#define pgJoystick_Type \
|
|
(*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 0])
|
|
#define pgJoystick_New \
|
|
(*(PyObject * (*)(int)) PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 1])
|
|
|
|
#define import_pygame_joystick() IMPORT_PYGAME_MODULE(joystick, JOYSTICK)
|
|
#endif
|
|
|
|
/* DISPLAY */
|
|
#define PYGAMEAPI_DISPLAY_FIRSTSLOT \
|
|
(PYGAMEAPI_JOYSTICK_FIRSTSLOT + PYGAMEAPI_JOYSTICK_NUMSLOTS)
|
|
#define PYGAMEAPI_DISPLAY_NUMSLOTS 2
|
|
|
|
typedef struct {
|
|
#if IS_SDLv1
|
|
PyObject_HEAD SDL_VideoInfo info;
|
|
#else
|
|
PyObject_HEAD pg_VideoInfo info;
|
|
#endif
|
|
} pgVidInfoObject;
|
|
|
|
#define pgVidInfo_AsVidInfo(x) (((pgVidInfoObject *)x)->info)
|
|
#ifndef PYGAMEAPI_DISPLAY_INTERNAL
|
|
#define pgVidInfo_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 0])
|
|
|
|
#define pgVidInfo_Type \
|
|
(*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 0])
|
|
|
|
#if IS_SDLv1
|
|
#define pgVidInfo_New \
|
|
(*(PyObject * (*)(SDL_VideoInfo *)) \
|
|
PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 1])
|
|
#else
|
|
#define pgVidInfo_New \
|
|
(*(PyObject * (*)(pg_VideoInfo *)) \
|
|
PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 1])
|
|
#endif
|
|
|
|
#define import_pygame_display() IMPORT_PYGAME_MODULE(display, DISPLAY)
|
|
#endif
|
|
|
|
/* SURFACE */
|
|
#define PYGAMEAPI_SURFACE_FIRSTSLOT \
|
|
(PYGAMEAPI_DISPLAY_FIRSTSLOT + PYGAMEAPI_DISPLAY_NUMSLOTS)
|
|
#define PYGAMEAPI_SURFACE_NUMSLOTS 3
|
|
typedef struct {
|
|
PyObject_HEAD SDL_Surface *surf;
|
|
#if IS_SDLv2
|
|
int owner;
|
|
#endif /* IS_SDLv2 */
|
|
struct pgSubSurface_Data *subsurface; /*ptr to subsurface data (if a
|
|
* subsurface)*/
|
|
PyObject *weakreflist;
|
|
PyObject *locklist;
|
|
PyObject *dependency;
|
|
} pgSurfaceObject;
|
|
#define pgSurface_AsSurface(x) (((pgSurfaceObject *)x)->surf)
|
|
#ifndef PYGAMEAPI_SURFACE_INTERNAL
|
|
#define pgSurface_Check(x) \
|
|
(PyObject_IsInstance((x), \
|
|
(PyObject *)PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 0]))
|
|
#define pgSurface_Type \
|
|
(*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 0])
|
|
#if IS_SDLv1
|
|
#define pgSurface_New \
|
|
(*(PyObject * (*)(SDL_Surface *)) \
|
|
PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 1])
|
|
#else /* IS_SDLv2 */
|
|
#define pgSurface_New2 \
|
|
(*(PyObject * (*)(SDL_Surface *, int)) \
|
|
PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 1])
|
|
#endif /* IS_SDLv2 */
|
|
#define pgSurface_Blit \
|
|
(*(int (*)(PyObject *, PyObject *, SDL_Rect *, SDL_Rect *, \
|
|
int))PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 2])
|
|
|
|
#define import_pygame_surface() \
|
|
do { \
|
|
IMPORT_PYGAME_MODULE(surface, SURFACE); \
|
|
if (PyErr_Occurred() != NULL) \
|
|
break; \
|
|
IMPORT_PYGAME_MODULE(surflock, SURFLOCK); \
|
|
} while (0)
|
|
|
|
#if IS_SDLv2
|
|
#define pgSurface_New(surface) pgSurface_New2((surface), 1)
|
|
#define pgSurface_NewNoOwn(surface) pgSurface_New2((surface), 0)
|
|
#endif /* IS_SDLv2 */
|
|
|
|
#endif
|
|
|
|
/* SURFLOCK */ /*auto import/init by surface*/
|
|
#define PYGAMEAPI_SURFLOCK_FIRSTSLOT \
|
|
(PYGAMEAPI_SURFACE_FIRSTSLOT + PYGAMEAPI_SURFACE_NUMSLOTS)
|
|
#define PYGAMEAPI_SURFLOCK_NUMSLOTS 8
|
|
struct pgSubSurface_Data {
|
|
PyObject *owner;
|
|
int pixeloffset;
|
|
int offsetx, offsety;
|
|
};
|
|
|
|
typedef struct {
|
|
PyObject_HEAD PyObject *surface;
|
|
PyObject *lockobj;
|
|
PyObject *weakrefs;
|
|
} pgLifetimeLockObject;
|
|
|
|
#ifndef PYGAMEAPI_SURFLOCK_INTERNAL
|
|
#define pgLifetimeLock_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 0])
|
|
#define pgSurface_Prep(x) \
|
|
if (((pgSurfaceObject *)x)->subsurface) \
|
|
(*(*(void (*)( \
|
|
PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 1]))(x)
|
|
|
|
#define pgSurface_Unprep(x) \
|
|
if (((pgSurfaceObject *)x)->subsurface) \
|
|
(*(*(void (*)( \
|
|
PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 2]))(x)
|
|
|
|
#define pgSurface_Lock \
|
|
(*(int (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 3])
|
|
#define pgSurface_Unlock \
|
|
(*(int (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 4])
|
|
#define pgSurface_LockBy \
|
|
(*(int (*)(PyObject *, \
|
|
PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 5])
|
|
#define pgSurface_UnlockBy \
|
|
(*(int (*)(PyObject *, \
|
|
PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 6])
|
|
#define pgSurface_LockLifetime \
|
|
(*(PyObject * (*)(PyObject *, PyObject *)) \
|
|
PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 7])
|
|
#endif
|
|
|
|
/* EVENT */
|
|
#define PYGAMEAPI_EVENT_FIRSTSLOT \
|
|
(PYGAMEAPI_SURFLOCK_FIRSTSLOT + PYGAMEAPI_SURFLOCK_NUMSLOTS)
|
|
#if IS_SDLv1
|
|
#define PYGAMEAPI_EVENT_NUMSLOTS 4
|
|
#else /* IS_SDLv2 */
|
|
#define PYGAMEAPI_EVENT_NUMSLOTS 6
|
|
#endif /* IS_SDLv2 */
|
|
|
|
typedef struct {
|
|
PyObject_HEAD int type;
|
|
PyObject *dict;
|
|
} pgEventObject;
|
|
|
|
#ifndef PYGAMEAPI_EVENT_INTERNAL
|
|
#define pgEvent_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 0])
|
|
#define pgEvent_Type \
|
|
(*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 0])
|
|
#define pgEvent_New \
|
|
(*(PyObject * (*)(SDL_Event *)) \
|
|
PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 1])
|
|
#define pgEvent_New2 \
|
|
(*(PyObject * (*)(int, PyObject *)) \
|
|
PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 2])
|
|
#define pgEvent_FillUserEvent \
|
|
(*(int (*)(pgEventObject *, \
|
|
SDL_Event *))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 3])
|
|
#if IS_SDLv2
|
|
#define pg_EnableKeyRepeat \
|
|
(*(int (*)(int, int))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 4])
|
|
#define pg_GetKeyRepeat \
|
|
(*(void (*)(int *, int *))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 5])
|
|
#endif /* IS_SDLv2 */
|
|
#define import_pygame_event() IMPORT_PYGAME_MODULE(event, EVENT)
|
|
#endif
|
|
|
|
/* RWOBJECT */
|
|
/*the rwobject are only needed for C side work, not accessable from python*/
|
|
#define PYGAMEAPI_RWOBJECT_FIRSTSLOT \
|
|
(PYGAMEAPI_EVENT_FIRSTSLOT + PYGAMEAPI_EVENT_NUMSLOTS)
|
|
#define PYGAMEAPI_RWOBJECT_NUMSLOTS 6
|
|
#ifndef PYGAMEAPI_RWOBJECT_INTERNAL
|
|
#define pgRWops_FromObject \
|
|
(*(SDL_RWops * (*)(PyObject *)) \
|
|
PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 0])
|
|
#define pgRWops_IsFileObject \
|
|
(*(int (*)(SDL_RWops *))PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 1])
|
|
#define pg_EncodeFilePath \
|
|
(*(PyObject * (*)(PyObject *, PyObject *)) \
|
|
PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 2])
|
|
#define pg_EncodeString \
|
|
(*(PyObject * (*)(PyObject *, const char *, const char *, PyObject *)) \
|
|
PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 3])
|
|
#define pgRWops_FromFileObject \
|
|
(*(SDL_RWops * (*)(PyObject *)) \
|
|
PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 4])
|
|
#define pgRWops_ReleaseObject \
|
|
(*(int (*)(SDL_RWops *)) \
|
|
PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 5])
|
|
#define import_pygame_rwobject() IMPORT_PYGAME_MODULE(rwobject, RWOBJECT)
|
|
|
|
#endif
|
|
|
|
/* PixelArray */
|
|
#define PYGAMEAPI_PIXELARRAY_FIRSTSLOT \
|
|
(PYGAMEAPI_RWOBJECT_FIRSTSLOT + PYGAMEAPI_RWOBJECT_NUMSLOTS)
|
|
#define PYGAMEAPI_PIXELARRAY_NUMSLOTS 2
|
|
#ifndef PYGAMEAPI_PIXELARRAY_INTERNAL
|
|
#define PyPixelArray_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_PIXELARRAY_FIRSTSLOT + 0])
|
|
#define PyPixelArray_New \
|
|
(*(PyObject * (*)) PyGAME_C_API[PYGAMEAPI_PIXELARRAY_FIRSTSLOT + 1])
|
|
#define import_pygame_pixelarray() IMPORT_PYGAME_MODULE(pixelarray, PIXELARRAY)
|
|
#endif /* PYGAMEAPI_PIXELARRAY_INTERNAL */
|
|
|
|
/* Color */
|
|
#define PYGAMEAPI_COLOR_FIRSTSLOT \
|
|
(PYGAMEAPI_PIXELARRAY_FIRSTSLOT + PYGAMEAPI_PIXELARRAY_NUMSLOTS)
|
|
#define PYGAMEAPI_COLOR_NUMSLOTS 4
|
|
#ifndef PYGAMEAPI_COLOR_INTERNAL
|
|
#define pgColor_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 0])
|
|
#define pgColor_Type (*(PyObject *)PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT])
|
|
#define pgColor_New \
|
|
(*(PyObject * (*)(Uint8 *)) PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 1])
|
|
#define pgColor_NewLength \
|
|
(*(PyObject * (*)(Uint8 *, Uint8)) \
|
|
PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 3])
|
|
|
|
#define pg_RGBAFromColorObj \
|
|
(*(int (*)(PyObject *, \
|
|
Uint8 *))PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 2])
|
|
#define import_pygame_color() IMPORT_PYGAME_MODULE(color, COLOR)
|
|
#endif /* PYGAMEAPI_COLOR_INTERNAL */
|
|
|
|
/* Math */
|
|
#define PYGAMEAPI_MATH_FIRSTSLOT \
|
|
(PYGAMEAPI_COLOR_FIRSTSLOT + PYGAMEAPI_COLOR_NUMSLOTS)
|
|
#define PYGAMEAPI_MATH_NUMSLOTS 2
|
|
#ifndef PYGAMEAPI_MATH_INTERNAL
|
|
#define pgVector2_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 0])
|
|
#define pgVector3_Check(x) \
|
|
((x)->ob_type == \
|
|
(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 1])
|
|
/*
|
|
#define pgVector2_New \
|
|
(*(PyObject*(*)) PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 1])
|
|
*/
|
|
#define import_pygame_math() IMPORT_PYGAME_MODULE(math, MATH)
|
|
#endif /* PYGAMEAPI_MATH_INTERNAL */
|
|
|
|
#define PG_CAPSULE_NAME(m) (IMPPREFIX m "." PYGAMEAPI_LOCAL_ENTRY)
|
|
|
|
#define _IMPORT_PYGAME_MODULE(module, MODULE, api_root) \
|
|
{ \
|
|
PyObject *_module = PyImport_ImportModule(IMPPREFIX #module); \
|
|
\
|
|
if (_module != NULL) { \
|
|
PyObject *_c_api = \
|
|
PyObject_GetAttrString(_module, PYGAMEAPI_LOCAL_ENTRY); \
|
|
\
|
|
Py_DECREF(_module); \
|
|
if (_c_api != NULL && PyCapsule_CheckExact(_c_api)) { \
|
|
void **localptr = (void **)PyCapsule_GetPointer( \
|
|
_c_api, PG_CAPSULE_NAME(#module)); \
|
|
\
|
|
if (localptr != NULL) { \
|
|
memcpy(api_root + PYGAMEAPI_##MODULE##_FIRSTSLOT, \
|
|
localptr, \
|
|
sizeof(void **) * PYGAMEAPI_##MODULE##_NUMSLOTS); \
|
|
} \
|
|
} \
|
|
Py_XDECREF(_c_api); \
|
|
} \
|
|
}
|
|
|
|
#ifndef NO_PYGAME_C_API
|
|
#define IMPORT_PYGAME_MODULE(module, MODULE) \
|
|
_IMPORT_PYGAME_MODULE(module, MODULE, PyGAME_C_API)
|
|
#define PYGAMEAPI_TOTALSLOTS \
|
|
(PYGAMEAPI_MATH_FIRSTSLOT + PYGAMEAPI_MATH_NUMSLOTS)
|
|
|
|
#ifdef PYGAME_H
|
|
void *PyGAME_C_API[PYGAMEAPI_TOTALSLOTS] = {NULL};
|
|
#else
|
|
extern void *PyGAME_C_API[PYGAMEAPI_TOTALSLOTS];
|
|
#endif
|
|
#endif
|
|
|
|
#if PG_HAVE_CAPSULE
|
|
#define encapsulate_api(ptr, module) \
|
|
PyCapsule_New(ptr, PG_CAPSULE_NAME(module), NULL)
|
|
#else
|
|
#define encapsulate_api(ptr, module) PyCObject_FromVoidPtr(ptr, NULL)
|
|
#endif
|
|
|
|
#ifndef PG_INLINE
|
|
#if defined(__clang__)
|
|
#define PG_INLINE __inline__ __attribute__((__unused__))
|
|
#elif defined(__GNUC__)
|
|
#define PG_INLINE __inline__
|
|
#elif defined(_MSC_VER)
|
|
#define PG_INLINE __inline
|
|
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
|
|
#define PG_INLINE inline
|
|
#else
|
|
#define PG_INLINE
|
|
#endif
|
|
#endif
|
|
|
|
/*last platform compiler stuff*/
|
|
#if defined(macintosh) && defined(__MWERKS__) || defined(__SYMBIAN32__)
|
|
#define PYGAME_EXPORT __declspec(export)
|
|
#else
|
|
#define PYGAME_EXPORT
|
|
#endif
|
|
|
|
|
|
#endif /* PYGAME_H */
|