mirrors/mkxp-z
1
0
Fork 0
mirror of https://github.com/mkxp-z/mkxp-z.git synced 2025-08-04 14:05:32 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

OLD_RUBY -> RAPI_MAJOR/RAPI_MINOR/RAPI_TEENY/RAPI_FULL

Browse source
This commit is contained in:
Struma 2020-02-26 12:44:37 -05:00 • committed by Roza
parent 429bf753cc
commit 94e063c6c0
20 changed files with 1950 additions and 2199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
binding/binding-mri.cpp
View file

@ -38,7 +38,7 @@
extern "C" { extern "C" {
#include <ruby.h> #include <ruby.h>
#ifndef OLD_RUBY #if RAPI_FULL >= 190
#include <ruby/encoding.h> #include <ruby/encoding.h>
#endif #endif
} }
@ -369,7 +369,7 @@ RB_METHOD(mriRgssMain) {
while (true) { while (true) {
VALUE exc = Qnil; VALUE exc = Qnil;
#if RUBYCOMPAT < 270 #if RAPI_FULL < 270
rb_rescue2((VALUE(*)(ANYARGS))rgssMainCb, rb_block_proc(), rb_rescue2((VALUE(*)(ANYARGS))rgssMainCb, rb_block_proc(),
(VALUE(*)(ANYARGS))rgssMainRescue, (VALUE)&exc, rb_eException, (VALUE(*)(ANYARGS))rgssMainRescue, (VALUE)&exc, rb_eException,
(VALUE)0); (VALUE)0);
@ -431,7 +431,7 @@ RB_METHOD(_kernelCaller) {
return trace; return trace;
} }
#ifndef OLD_RUBY #if RAPI_FULL > 187
static VALUE newStringUTF8(const char *string, long length) { static VALUE newStringUTF8(const char *string, long length) {
return rb_enc_str_new(string, length, rb_utf8_encoding()); return rb_enc_str_new(string, length, rb_utf8_encoding());
} }
@ -571,7 +571,7 @@ static void runRMXPScripts(BacktraceData &btData) {
#endif #endif
while (true) { while (true) {
#if defined(OLD_RUBY) && defined(NO_CONSOLE) #if RAPI_FULL < 200 && defined(NO_CONSOLE)
VALUE iostr = rb_str_new2(NULL_IO); VALUE iostr = rb_str_new2(NULL_IO);
// Sysinit isn't a thing yet, so send io to /dev/null instead // Sysinit isn't a thing yet, so send io to /dev/null instead
rb_funcall(rb_gv_get("$stderr"), rb_intern("reopen"), 1, iostr); rb_funcall(rb_gv_get("$stderr"), rb_intern("reopen"), 1, iostr);
@ -694,7 +694,7 @@ static void showExc(VALUE exc, const BacktraceData &btData) {
} }
static void mriBindingExecute() { static void mriBindingExecute() {
#ifndef OLD_RUBY #if RAPI_FULL > 200
/* Normally only a ruby executable would do a sysinit, /* Normally only a ruby executable would do a sysinit,
* but not doing it will lead to crashes due to closed * but not doing it will lead to crashes due to closed
* stdio streams on some platforms (eg. Windows) */ * stdio streams on some platforms (eg. Windows) */
@ -750,7 +750,7 @@ static void mriBindingExecute() {
runRMXPScripts(btData); runRMXPScripts(btData);
#endif #endif
#ifndef OLD_RUBY #if RAPI_FULL > 187
VALUE exc = rb_errinfo(); VALUE exc = rb_errinfo();
#else #else
VALUE exc = rb_gv_get("$!"); VALUE exc = rb_gv_get("$!");

4
binding/binding-types.h
View file

@ -24,7 +24,7 @@
#include "binding-util.h" #include "binding-util.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DECL_TYPE(Table); DECL_TYPE(Table);
DECL_TYPE(Rect); DECL_TYPE(Rect);
DECL_TYPE(Color); DECL_TYPE(Color);
@ -59,7 +59,7 @@ DECL_TYPE(MiniFFI);
#ifdef HAVE_DISCORDSDK #ifdef HAVE_DISCORDSDK
#ifndef OLD_RUBY #if RAPI_FULL > 187
DECL_TYPE(DCActivity); DECL_TYPE(DCActivity);
#else #else

146
binding/binding-util.cpp
View file

@ -21,76 +21,61 @@
#include "binding-util.h" #include "binding-util.h"
#include "sharedstate.h"
#include "exception.h" #include "exception.h"
#include "sharedstate.h"
#include "src/util.h" #include "src/util.h"
#include <assert.h>
#include <stdarg.h> #include <stdarg.h>
#include <string.h> #include <string.h>
#include <assert.h>
RbData *getRbData() RbData *getRbData() { return static_cast<RbData *>(shState->bindingData()); }
{
return static_cast<RbData*>(shState->bindingData());
}
struct struct {
{
RbException id; RbException id;
const char *name; const char *name;
} static customExc[] = } static customExc[] = {
{ {MKXP, "MKXPError"}, {PHYSFS, "PHYSFSError"}, {SDL, "SDLError"}};
{ MKXP, "MKXPError" },
{ PHYSFS, "PHYSFSError" },
{ SDL, "SDLError" }
};
RbData::RbData() RbData::RbData() {
{
for (size_t i = 0; i < ARRAY_SIZE(customExc); ++i) for (size_t i = 0; i < ARRAY_SIZE(customExc); ++i)
exc[customExc[i].id] = rb_define_class(customExc[i].name, rb_eException); exc[customExc[i].id] = rb_define_class(customExc[i].name, rb_eException);
exc[RGSS] = rb_define_class("RGSSError", rb_eStandardError); exc[RGSS] = rb_define_class("RGSSError", rb_eStandardError);
exc[Reset] = rb_define_class(rgssVer >= 3 ? "RGSSReset" : "Reset", rb_eException); exc[Reset] =
rb_define_class(rgssVer >= 3 ? "RGSSReset" : "Reset", rb_eException);
exc[ErrnoENOENT] = rb_const_get(rb_const_get(rb_cObject, rb_intern("Errno")), rb_intern("ENOENT")); exc[ErrnoENOENT] = rb_const_get(rb_const_get(rb_cObject, rb_intern("Errno")),
rb_intern("ENOENT"));
exc[IOError] = rb_eIOError; exc[IOError] = rb_eIOError;
exc[TypeError] = rb_eTypeError; exc[TypeError] = rb_eTypeError;
exc[ArgumentError] = rb_eArgError; exc[ArgumentError] = rb_eArgError;
} }
RbData::~RbData() RbData::~RbData() {}
{
}
/* Indexed with Exception::Type */ /* Indexed with Exception::Type */
static const RbException excToRbExc[] = static const RbException excToRbExc[] = {
{
RGSS, /* RGSSError */ RGSS, /* RGSSError */
ErrnoENOENT, /* NoFileError */ ErrnoENOENT, /* NoFileError */
IOError, IOError,
TypeError, TypeError, ArgumentError,
ArgumentError,
PHYSFS, /* PHYSFSError */ PHYSFS, /* PHYSFSError */
SDL, /* SDLError */ SDL, /* SDLError */
MKXP /* MKXPError */ MKXP /* MKXPError */
}; };
void raiseRbExc(const Exception &exc) void raiseRbExc(const Exception &exc) {
{
RbData *data = getRbData(); RbData *data = getRbData();
VALUE excClass = data->exc[excToRbExc[exc.type]]; VALUE excClass = data->exc[excToRbExc[exc.type]];
rb_raise(excClass, "%s", exc.msg.c_str()); rb_raise(excClass, "%s", exc.msg.c_str());
} }
void void raiseDisposedAccess(VALUE self) {
raiseDisposedAccess(VALUE self) #if RAPI_FULL > 187
{
#ifndef OLD_RUBY
const char *klassName = RTYPEDDATA_TYPE(self)->wrap_struct_name; const char *klassName = RTYPEDDATA_TYPE(self)->wrap_struct_name;
#else #else
const char *klassName = rb_obj_classname(self); const char *klassName = rb_obj_classname(self);
@ -103,9 +88,7 @@ raiseDisposedAccess(VALUE self)
rb_raise(getRbData()->exc[RGSS], "disposed %s", buf); rb_raise(getRbData()->exc[RGSS], "disposed %s", buf);
} }
int int rb_get_args(int argc, VALUE *argv, const char *format, ...) {
rb_get_args(int argc, VALUE *argv, const char *format, ...)
{
char c; char c;
VALUE *arg = argv; VALUE *arg = argv;
va_list ap; va_list ap;
@ -114,11 +97,9 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
va_start(ap, format); va_start(ap, format);
while ((c = *format++)) while ((c = *format++)) {
{ switch (c) {
switch (c) case '|':
{
case '|' :
break; break;
default: default:
// FIXME print num of needed args vs provided // FIXME print num of needed args vs provided
@ -131,14 +112,12 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
if (argI >= argc) if (argI >= argc)
break; break;
switch (c) switch (c) {
{ case 'o': {
case 'o' :
{
if (argI >= argc) if (argI >= argc)
break; break;
VALUE *obj = va_arg(ap, VALUE*); VALUE *obj = va_arg(ap, VALUE *);
*obj = *arg++; *obj = *arg++;
++argI; ++argI;
@ -146,12 +125,11 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 'S' : case 'S': {
{
if (argI >= argc) if (argI >= argc)
break; break;
VALUE *str = va_arg(ap, VALUE*); VALUE *str = va_arg(ap, VALUE *);
VALUE tmp = *arg; VALUE tmp = *arg;
if (!RB_TYPE_P(tmp, RUBY_T_STRING)) if (!RB_TYPE_P(tmp, RUBY_T_STRING))
@ -163,13 +141,12 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 's' : case 's': {
{
if (argI >= argc) if (argI >= argc)
break; break;
const char **s = va_arg(ap, const char**); const char **s = va_arg(ap, const char **);
int *len = va_arg(ap, int*); int *len = va_arg(ap, int *);
VALUE tmp = *arg; VALUE tmp = *arg;
@ -183,12 +160,11 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 'z' : case 'z': {
{
if (argI >= argc) if (argI >= argc)
break; break;
const char **s = va_arg(ap, const char**); const char **s = va_arg(ap, const char **);
VALUE tmp = *arg++; VALUE tmp = *arg++;
@ -201,12 +177,11 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 'f' : case 'f': {
{
if (argI >= argc) if (argI >= argc)
break; break;
double *f = va_arg(ap, double*); double *f = va_arg(ap, double *);
VALUE fVal = *arg++; VALUE fVal = *arg++;
rb_float_arg(fVal, f, argI); rb_float_arg(fVal, f, argI);
@ -215,12 +190,11 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 'i' : case 'i': {
{
if (argI >= argc) if (argI >= argc)
break; break;
int *i = va_arg(ap, int*); int *i = va_arg(ap, int *);
VALUE iVal = *arg++; VALUE iVal = *arg++;
rb_int_arg(iVal, i, argI); rb_int_arg(iVal, i, argI);
@ -229,12 +203,11 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 'b' : case 'b': {
{
if (argI >= argc) if (argI >= argc)
break; break;
bool *b = va_arg(ap, bool*); bool *b = va_arg(ap, bool *);
VALUE bVal = *arg++; VALUE bVal = *arg++;
rb_bool_arg(bVal, b, argI); rb_bool_arg(bVal, b, argI);
@ -243,12 +216,11 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case 'n' : case 'n': {
{
if (argI >= argc) if (argI >= argc)
break; break;
ID *sym = va_arg(ap, ID*); ID *sym = va_arg(ap, ID *);
VALUE symVal = *arg++; VALUE symVal = *arg++;
@ -261,7 +233,7 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
break; break;
} }
case '|' : case '|':
opt = true; opt = true;
break; break;
@ -276,34 +248,32 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
* the stack to check for RB_ARG_END */ * the stack to check for RB_ARG_END */
format--; format--;
while ((c = *format++)) while ((c = *format++)) {
{ switch (c) {
switch (c) case 'o':
{ case 'S':
case 'o' : va_arg(ap, VALUE *);
case 'S' :
va_arg(ap, VALUE*);
break; break;
case 's' : case 's':
va_arg(ap, const char**); va_arg(ap, const char **);
va_arg(ap, int*); va_arg(ap, int *);
break; break;
case 'z' : case 'z':
va_arg(ap, const char**); va_arg(ap, const char **);
break; break;
case 'f' : case 'f':
va_arg(ap, double*); va_arg(ap, double *);
break; break;
case 'i' : case 'i':
va_arg(ap, int*); va_arg(ap, int *);
break; break;
case 'b' : case 'b':
va_arg(ap, bool*); va_arg(ap, bool *);
break; break;
} }
} }
@ -313,8 +283,8 @@ rb_get_args(int argc, VALUE *argv, const char *format, ...)
rb_raise(rb_eArgError, "wrong number of arguments"); rb_raise(rb_eArgError, "wrong number of arguments");
/* Verify correct termination */ /* Verify correct termination */
void *argEnd = va_arg(ap, void*); void *argEnd = va_arg(ap, void *);
(void) argEnd; (void)argEnd;
assert(argEnd == RB_ARG_END_VAL); assert(argEnd == RB_ARG_END_VAL);
#endif #endif

54
binding/binding-util.h
View file

@ -23,9 +23,25 @@
#define BINDING_UTIL_H #define BINDING_UTIL_H
#include <ruby.h> #include <ruby.h>
#ifndef LEGACY_RUBY
#include <ruby/version.h>
#else
#include <version.h>
#endif
#include "exception.h" #include "exception.h"
#ifdef RUBY_API_VERSION_MAJOR
#define RAPI_MAJOR RUBY_API_VERSION_MAJOR
#define RAPI_MINOR RUBY_API_VERSION_MINOR
#define RAPI_TEENY RUBY_API_VERSION_TEENY
#else
#define RAPI_MAJOR RUBY_VERSION_MAJOR
#define RAPI_MINOR RUBY_VERSION_MINOR
#define RAPI_TEENY RUBY_VERSION_TEENY
#endif
#define RAPI_FULL ((RAPI_MAJOR * 100) + (RAPI_MINOR * 10) + RAPI_TEENY)
enum RbException { enum RbException {
RGSS = 0, RGSS = 0,
Reset, Reset,
@ -59,12 +75,11 @@ struct Exception;
void raiseRbExc(const Exception &exc); void raiseRbExc(const Exception &exc);
#ifndef OLD_RUBY #if RAPI_FULL > 187
#define DECL_TYPE(Klass) extern rb_data_type_t Klass##Type #define DECL_TYPE(Klass) extern rb_data_type_t Klass##Type
/* 2.1 has added a new field (flags) to rb_data_type_t */ /* 2.1 has added a new field (flags) to rb_data_type_t */
#include <ruby/version.h> #if RAPI_FULL >= 210
#if RUBY_API_VERSION_MAJOR >= 2 && RUBY_API_VERSION_MINOR >= 1
/* TODO: can mkxp use RUBY_TYPED_FREE_IMMEDIATELY here? */ /* TODO: can mkxp use RUBY_TYPED_FREE_IMMEDIATELY here? */
#define DEF_TYPE_FLAGS 0 #define DEF_TYPE_FLAGS 0
#else #else
@ -72,15 +87,14 @@ void raiseRbExc(const Exception &exc);
#endif #endif
#endif #endif
#ifndef OLD_RUBY #if RAPI_MAJOR > 1
#if RUBYCOMPAT < 270 #if RAPI_FULL < 270
#define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free) \ #define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free) \
rb_data_type_t Klass##Type = { \ rb_data_type_t Klass##Type = { \
Name, {0, Free, 0, {0, 0}}, 0, 0, DEF_TYPE_FLAGS} Name, {0, Free, 0, {0, 0}}, 0, 0, DEF_TYPE_FLAGS}
#else #else
#define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free) \ #define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free) \
rb_data_type_t Klass##Type = { \ rb_data_type_t Klass##Type = {Name, {0, Free, 0, 0, 0}, 0, 0, DEF_TYPE_FLAGS}
Name, {0, Free, 0, 0, 0}, 0, 0, DEF_TYPE_FLAGS}
#endif #endif
#define DEF_TYPE_CUSTOMFREE(Klass, Free) \ #define DEF_TYPE_CUSTOMFREE(Klass, Free) \
@ -93,7 +107,7 @@ void raiseRbExc(const Exception &exc);
#endif #endif
// Ruby 1.8 helper stuff // Ruby 1.8 helper stuff
#ifdef OLD_RUBY #if RAPI_FULL <= 187
#define RUBY_T_FIXNUM T_FIXNUM #define RUBY_T_FIXNUM T_FIXNUM
#define RUBY_T_TRUE T_TRUE #define RUBY_T_TRUE T_TRUE
@ -144,10 +158,10 @@ void raiseRbExc(const Exception &exc);
#endif #endif
// end // end
#ifndef OLD_RUBY #if RAPI_FULL > 187
template <rb_data_type_t *rbType> static VALUE classAllocate(VALUE klass) { template <rb_data_type_t *rbType> static VALUE classAllocate(VALUE klass) {
/* 2.3 has changed the name of this function */ /* 2.3 has changed the name of this function */
#if RUBY_API_VERSION_MAJOR >= 2 && RUBY_API_VERSION_MINOR >= 3 #if RAPI_FULL >= 230
return rb_data_typed_object_wrap(klass, 0, rbType); return rb_data_typed_object_wrap(klass, 0, rbType);
#else #else
return rb_data_typed_object_alloc(klass, 0, rbType); return rb_data_typed_object_alloc(klass, 0, rbType);
@ -162,7 +176,7 @@ template <class C> static void freeInstance(void *inst) {
void raiseDisposedAccess(VALUE self); void raiseDisposedAccess(VALUE self);
template <class C> inline C *getPrivateData(VALUE self) { template <class C> inline C *getPrivateData(VALUE self) {
#ifndef OLD_RUBY #if RAPI_FULL > 187
C *c = static_cast<C *>(RTYPEDDATA_DATA(self)); C *c = static_cast<C *>(RTYPEDDATA_DATA(self));
#else #else
C *c = static_cast<C *>(DATA_PTR(self)); C *c = static_cast<C *>(DATA_PTR(self));
@ -172,13 +186,13 @@ template <class C> inline C *getPrivateData(VALUE self) {
template <class C> template <class C>
static inline C * static inline C *
#ifndef OLD_RUBY #if RAPI_FULL > 187
getPrivateDataCheck(VALUE self, const rb_data_type_t &type) getPrivateDataCheck(VALUE self, const rb_data_type_t &type)
#else #else
getPrivateDataCheck(VALUE self, const char *type) getPrivateDataCheck(VALUE self, const char *type)
#endif #endif
{ {
#ifdef OLD_RUBY #if RAPI_FULL <= 187
rb_check_type(self, T_DATA); rb_check_type(self, T_DATA);
VALUE otherObj = rb_const_get(rb_cObject, rb_intern(type)); VALUE otherObj = rb_const_get(rb_cObject, rb_intern(type));
#else #else
@ -197,7 +211,7 @@ getPrivateDataCheck(VALUE self, const char *type)
} }
static inline void setPrivateData(VALUE self, void *p) { static inline void setPrivateData(VALUE self, void *p) {
#ifndef OLD_RUBY #if RAPI_FULL > 187
RTYPEDDATA_DATA(self) = p; RTYPEDDATA_DATA(self) = p;
#else #else
DATA_PTR(self) = p; DATA_PTR(self) = p;
@ -205,13 +219,13 @@ static inline void setPrivateData(VALUE self, void *p) {
} }
inline VALUE inline VALUE
#ifndef OLD_RUBY #if RAPI_FULL > 187
wrapObject(void *p, const rb_data_type_t &type, VALUE underKlass = rb_cObject) wrapObject(void *p, const rb_data_type_t &type, VALUE underKlass = rb_cObject)
#else #else
wrapObject(void *p, const char *type, VALUE underKlass = rb_cObject) wrapObject(void *p, const char *type, VALUE underKlass = rb_cObject)
#endif #endif
{ {
#ifndef OLD_RUBY #if RAPI_FULL > 187
VALUE klass = rb_const_get(underKlass, rb_intern(type.wrap_struct_name)); VALUE klass = rb_const_get(underKlass, rb_intern(type.wrap_struct_name));
#else #else
VALUE klass = rb_const_get(underKlass, rb_intern(type)); VALUE klass = rb_const_get(underKlass, rb_intern(type));
@ -224,7 +238,7 @@ wrapObject(void *p, const char *type, VALUE underKlass = rb_cObject)
} }
inline VALUE wrapProperty(VALUE self, void *prop, const char *iv, inline VALUE wrapProperty(VALUE self, void *prop, const char *iv,
#ifndef OLD_RUBY #if RAPI_FULL > 187
const rb_data_type_t &type, const rb_data_type_t &type,
#else #else
const char *type, const char *type,
@ -346,7 +360,7 @@ inline void rb_check_argc(int actual, int expected) {
expected); expected);
} }
#ifdef OLD_RUBY #if RAPI_FULL <= 187
static inline void rb_error_arity(int argc, int min, int max) { static inline void rb_error_arity(int argc, int min, int max) {
if (argc > max || argc < min) if (argc > max || argc < min)
rb_raise(rb_eArgError, "Finish me! rb_error_arity()"); // TODO rb_raise(rb_eArgError, "Finish me! rb_error_arity()"); // TODO
@ -395,7 +409,7 @@ static inline VALUE rb_file_open_str(VALUE filename, const char *mode) {
* FIXME: Getter assumes prop is disposable, * FIXME: Getter assumes prop is disposable,
* because self.disposed? is not checked in this case. * because self.disposed? is not checked in this case.
* Should make this more clear */ * Should make this more clear */
#ifndef OLD_RUBY #if RAPI_FULL > 187
#define DEF_PROP_OBJ_REF(Klass, PropKlass, PropName, prop_iv) \ #define DEF_PROP_OBJ_REF(Klass, PropKlass, PropName, prop_iv) \
RB_METHOD(Klass##Get##PropName) { \ RB_METHOD(Klass##Get##PropName) { \
RB_UNUSED_PARAM; \ RB_UNUSED_PARAM; \
@ -438,7 +452,7 @@ static inline VALUE rb_file_open_str(VALUE filename, const char *mode) {
#endif #endif
/* Object property which is copied by value, not reference */ /* Object property which is copied by value, not reference */
#ifndef OLD_RUBY #if RAPI_FULL > 187
#define DEF_PROP_OBJ_VAL(Klass, PropKlass, PropName, prop_iv) \ #define DEF_PROP_OBJ_VAL(Klass, PropKlass, PropName, prop_iv) \
RB_METHOD(Klass##Get##PropName) { \ RB_METHOD(Klass##Get##PropName) { \
RB_UNUSED_PARAM; \ RB_UNUSED_PARAM; \

220
binding/bitmap-binding.cpp
View file

@ -19,28 +19,26 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "bitmap.h"
#include "font.h"
#include "exception.h"
#include "sharedstate.h"
#include "disposable-binding.h"
#include "binding-util.h"
#include "binding-types.h" #include "binding-types.h"
#include "binding-util.h"
#include "bitmap.h"
#include "disposable-binding.h"
#include "exception.h"
#include "font.h"
#include "sharedstate.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Bitmap); DEF_TYPE(Bitmap);
#else #else
DEF_ALLOCFUNC(Bitmap); DEF_ALLOCFUNC(Bitmap);
#endif #endif
static const char *objAsStringPtr(VALUE obj) static const char *objAsStringPtr(VALUE obj) {
{
VALUE str = rb_obj_as_string(obj); VALUE str = rb_obj_as_string(obj);
return RSTRING_PTR(str); return RSTRING_PTR(str);
} }
void bitmapInitProps(Bitmap *b, VALUE self) void bitmapInitProps(Bitmap *b, VALUE self) {
{
/* Wrap properties */ /* Wrap properties */
VALUE fontKlass = rb_const_get(rb_cObject, rb_intern("Font")); VALUE fontKlass = rb_const_get(rb_cObject, rb_intern("Font"));
VALUE fontObj = rb_obj_alloc(fontKlass); VALUE fontObj = rb_obj_alloc(fontKlass);
@ -52,23 +50,19 @@ void bitmapInitProps(Bitmap *b, VALUE self)
rb_iv_set(self, "font", fontObj); rb_iv_set(self, "font", fontObj);
} }
RB_METHOD(bitmapInitialize) RB_METHOD(bitmapInitialize) {
{
Bitmap *b = 0; Bitmap *b = 0;
if (argc == 1) if (argc == 1) {
{
char *filename; char *filename;
rb_get_args(argc, argv, "z", &filename RB_ARG_END); rb_get_args(argc, argv, "z", &filename RB_ARG_END);
GUARD_EXC( b = new Bitmap(filename); ) GUARD_EXC(b = new Bitmap(filename);)
} } else {
else
{
int width, height; int width, height;
rb_get_args(argc, argv, "ii", &width, &height RB_ARG_END); rb_get_args(argc, argv, "ii", &width, &height RB_ARG_END);
GUARD_EXC( b = new Bitmap(width, height); ) GUARD_EXC(b = new Bitmap(width, height);)
} }
setPrivateData(self, b); setPrivateData(self, b);
@ -77,46 +71,42 @@ RB_METHOD(bitmapInitialize)
return self; return self;
} }
RB_METHOD(bitmapWidth) RB_METHOD(bitmapWidth) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int value = 0; int value = 0;
GUARD_EXC( value = b->width(); ); GUARD_EXC(value = b->width(););
return INT2FIX(value); return INT2FIX(value);
} }
RB_METHOD(bitmapHeight) RB_METHOD(bitmapHeight) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int value = 0; int value = 0;
GUARD_EXC( value = b->height(); ); GUARD_EXC(value = b->height(););
return INT2FIX(value); return INT2FIX(value);
} }
RB_METHOD(bitmapRect) RB_METHOD(bitmapRect) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
IntRect rect; IntRect rect;
GUARD_EXC( rect = b->rect(); ); GUARD_EXC(rect = b->rect(););
Rect *r = new Rect(rect); Rect *r = new Rect(rect);
return wrapObject(r, RectType); return wrapObject(r, RectType);
} }
RB_METHOD(bitmapBlt) RB_METHOD(bitmapBlt) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int x, y; int x, y;
@ -127,18 +117,18 @@ RB_METHOD(bitmapBlt)
Bitmap *src; Bitmap *src;
Rect *srcRect; Rect *srcRect;
rb_get_args(argc, argv, "iioo|i", &x, &y, &srcObj, &srcRectObj, &opacity RB_ARG_END); rb_get_args(argc, argv, "iioo|i", &x, &y, &srcObj, &srcRectObj,
&opacity RB_ARG_END);
src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType); src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType);
srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType); srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType);
GUARD_EXC( b->blt(x, y, *src, srcRect->toIntRect(), opacity); ); GUARD_EXC(b->blt(x, y, *src, srcRect->toIntRect(), opacity););
return self; return self;
} }
RB_METHOD(bitmapStretchBlt) RB_METHOD(bitmapStretchBlt) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
VALUE destRectObj; VALUE destRectObj;
@ -149,26 +139,26 @@ RB_METHOD(bitmapStretchBlt)
Bitmap *src; Bitmap *src;
Rect *destRect, *srcRect; Rect *destRect, *srcRect;
rb_get_args(argc, argv, "ooo|i", &destRectObj, &srcObj, &srcRectObj, &opacity RB_ARG_END); rb_get_args(argc, argv, "ooo|i", &destRectObj, &srcObj, &srcRectObj,
&opacity RB_ARG_END);
src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType); src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType);
destRect = getPrivateDataCheck<Rect>(destRectObj, RectType); destRect = getPrivateDataCheck<Rect>(destRectObj, RectType);
srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType); srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType);
GUARD_EXC( b->stretchBlt(destRect->toIntRect(), *src, srcRect->toIntRect(), opacity); ); GUARD_EXC(b->stretchBlt(destRect->toIntRect(), *src, srcRect->toIntRect(),
opacity););
return self; return self;
} }
RB_METHOD(bitmapFillRect) RB_METHOD(bitmapFillRect) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
VALUE colorObj; VALUE colorObj;
Color *color; Color *color;
if (argc == 2) if (argc == 2) {
{
VALUE rectObj; VALUE rectObj;
Rect *rect; Rect *rect;
@ -177,35 +167,32 @@ RB_METHOD(bitmapFillRect)
rect = getPrivateDataCheck<Rect>(rectObj, RectType); rect = getPrivateDataCheck<Rect>(rectObj, RectType);
color = getPrivateDataCheck<Color>(colorObj, ColorType); color = getPrivateDataCheck<Color>(colorObj, ColorType);
GUARD_EXC( b->fillRect(rect->toIntRect(), color->norm); ); GUARD_EXC(b->fillRect(rect->toIntRect(), color->norm););
} } else {
else
{
int x, y, width, height; int x, y, width, height;
rb_get_args(argc, argv, "iiiio", &x, &y, &width, &height, &colorObj RB_ARG_END); rb_get_args(argc, argv, "iiiio", &x, &y, &width, &height,
&colorObj RB_ARG_END);
color = getPrivateDataCheck<Color>(colorObj, ColorType); color = getPrivateDataCheck<Color>(colorObj, ColorType);
GUARD_EXC( b->fillRect(x, y, width, height, color->norm); ); GUARD_EXC(b->fillRect(x, y, width, height, color->norm););
} }
return self; return self;
} }
RB_METHOD(bitmapClear) RB_METHOD(bitmapClear) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
GUARD_EXC( b->clear(); ) GUARD_EXC(b->clear();)
return self; return self;
} }
RB_METHOD(bitmapGetPixel) RB_METHOD(bitmapGetPixel) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int x, y; int x, y;
@ -213,15 +200,14 @@ RB_METHOD(bitmapGetPixel)
rb_get_args(argc, argv, "ii", &x, &y RB_ARG_END); rb_get_args(argc, argv, "ii", &x, &y RB_ARG_END);
Color value; Color value;
GUARD_EXC( value = b->getPixel(x, y); ); GUARD_EXC(value = b->getPixel(x, y););
Color *color = new Color(value); Color *color = new Color(value);
return wrapObject(color, ColorType); return wrapObject(color, ColorType);
} }
RB_METHOD(bitmapSetPixel) RB_METHOD(bitmapSetPixel) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int x, y; int x, y;
@ -233,94 +219,81 @@ RB_METHOD(bitmapSetPixel)
color = getPrivateDataCheck<Color>(colorObj, ColorType); color = getPrivateDataCheck<Color>(colorObj, ColorType);
GUARD_EXC( b->setPixel(x, y, *color); ); GUARD_EXC(b->setPixel(x, y, *color););
return self; return self;
} }
RB_METHOD(bitmapHueChange) RB_METHOD(bitmapHueChange) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int hue; int hue;
rb_get_args(argc, argv, "i", &hue RB_ARG_END); rb_get_args(argc, argv, "i", &hue RB_ARG_END);
GUARD_EXC( b->hueChange(hue); ); GUARD_EXC(b->hueChange(hue););
return self; return self;
} }
RB_METHOD(bitmapDrawText) RB_METHOD(bitmapDrawText) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
const char *str; const char *str;
int align = Bitmap::Left; int align = Bitmap::Left;
if (argc == 2 || argc == 3) if (argc == 2 || argc == 3) {
{
VALUE rectObj; VALUE rectObj;
Rect *rect; Rect *rect;
if (rgssVer >= 2) if (rgssVer >= 2) {
{
VALUE strObj; VALUE strObj;
rb_get_args(argc, argv, "oo|i", &rectObj, &strObj, &align RB_ARG_END); rb_get_args(argc, argv, "oo|i", &rectObj, &strObj, &align RB_ARG_END);
str = objAsStringPtr(strObj); str = objAsStringPtr(strObj);
} } else {
else
{
rb_get_args(argc, argv, "oz|i", &rectObj, &str, &align RB_ARG_END); rb_get_args(argc, argv, "oz|i", &rectObj, &str, &align RB_ARG_END);
} }
rect = getPrivateDataCheck<Rect>(rectObj, RectType); rect = getPrivateDataCheck<Rect>(rectObj, RectType);
GUARD_EXC( b->drawText(rect->toIntRect(), str, align); ); GUARD_EXC(b->drawText(rect->toIntRect(), str, align););
} } else {
else
{
int x, y, width, height; int x, y, width, height;
if (rgssVer >= 2) if (rgssVer >= 2) {
{
VALUE strObj; VALUE strObj;
rb_get_args(argc, argv, "iiiio|i", &x, &y, &width, &height, &strObj, &align RB_ARG_END); rb_get_args(argc, argv, "iiiio|i", &x, &y, &width, &height, &strObj,
&align RB_ARG_END);
str = objAsStringPtr(strObj); str = objAsStringPtr(strObj);
} } else {
else rb_get_args(argc, argv, "iiiiz|i", &x, &y, &width, &height, &str,
{ &align RB_ARG_END);
rb_get_args(argc, argv, "iiiiz|i", &x, &y, &width, &height, &str, &align RB_ARG_END);
} }
GUARD_EXC( b->drawText(x, y, width, height, str, align); ); GUARD_EXC(b->drawText(x, y, width, height, str, align););
} }
return self; return self;
} }
RB_METHOD(bitmapTextSize) RB_METHOD(bitmapTextSize) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
const char *str; const char *str;
if (rgssVer >= 2) if (rgssVer >= 2) {
{
VALUE strObj; VALUE strObj;
rb_get_args(argc, argv, "o", &strObj RB_ARG_END); rb_get_args(argc, argv, "o", &strObj RB_ARG_END);
str = objAsStringPtr(strObj); str = objAsStringPtr(strObj);
} } else {
else
{
rb_get_args(argc, argv, "z", &str RB_ARG_END); rb_get_args(argc, argv, "z", &str RB_ARG_END);
} }
IntRect value; IntRect value;
GUARD_EXC( value = b->textSize(str); ); GUARD_EXC(value = b->textSize(str););
Rect *rect = new Rect(value); Rect *rect = new Rect(value);
@ -329,50 +302,46 @@ RB_METHOD(bitmapTextSize)
DEF_PROP_OBJ_VAL(Bitmap, Font, Font, "font") DEF_PROP_OBJ_VAL(Bitmap, Font, Font, "font")
RB_METHOD(bitmapGradientFillRect) RB_METHOD(bitmapGradientFillRect) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
VALUE color1Obj, color2Obj; VALUE color1Obj, color2Obj;
Color *color1, *color2; Color *color1, *color2;
bool vertical = false; bool vertical = false;
if (argc == 3 || argc == 4) if (argc == 3 || argc == 4) {
{
VALUE rectObj; VALUE rectObj;
Rect *rect; Rect *rect;
rb_get_args(argc, argv, "ooo|b", &rectObj, rb_get_args(argc, argv, "ooo|b", &rectObj, &color1Obj, &color2Obj,
&color1Obj, &color2Obj, &vertical RB_ARG_END); &vertical RB_ARG_END);
rect = getPrivateDataCheck<Rect>(rectObj, RectType); rect = getPrivateDataCheck<Rect>(rectObj, RectType);
color1 = getPrivateDataCheck<Color>(color1Obj, ColorType); color1 = getPrivateDataCheck<Color>(color1Obj, ColorType);
color2 = getPrivateDataCheck<Color>(color2Obj, ColorType); color2 = getPrivateDataCheck<Color>(color2Obj, ColorType);
GUARD_EXC( b->gradientFillRect(rect->toIntRect(), color1->norm, color2->norm, vertical); ); GUARD_EXC(b->gradientFillRect(rect->toIntRect(), color1->norm, color2->norm,
} vertical););
else } else {
{
int x, y, width, height; int x, y, width, height;
rb_get_args(argc, argv, "iiiioo|b", &x, &y, &width, &height, rb_get_args(argc, argv, "iiiioo|b", &x, &y, &width, &height, &color1Obj,
&color1Obj, &color2Obj, &vertical RB_ARG_END); &color2Obj, &vertical RB_ARG_END);
color1 = getPrivateDataCheck<Color>(color1Obj, ColorType); color1 = getPrivateDataCheck<Color>(color1Obj, ColorType);
color2 = getPrivateDataCheck<Color>(color2Obj, ColorType); color2 = getPrivateDataCheck<Color>(color2Obj, ColorType);
GUARD_EXC( b->gradientFillRect(x, y, width, height, color1->norm, color2->norm, vertical); ); GUARD_EXC(b->gradientFillRect(x, y, width, height, color1->norm,
color2->norm, vertical););
} }
return self; return self;
} }
RB_METHOD(bitmapClearRect) RB_METHOD(bitmapClearRect) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
if (argc == 1) if (argc == 1) {
{
VALUE rectObj; VALUE rectObj;
Rect *rect; Rect *rect;
@ -380,22 +349,19 @@ RB_METHOD(bitmapClearRect)
rect = getPrivateDataCheck<Rect>(rectObj, RectType); rect = getPrivateDataCheck<Rect>(rectObj, RectType);
GUARD_EXC( b->clearRect(rect->toIntRect()); ); GUARD_EXC(b->clearRect(rect->toIntRect()););
} } else {
else
{
int x, y, width, height; int x, y, width, height;
rb_get_args(argc, argv, "iiii", &x, &y, &width, &height RB_ARG_END); rb_get_args(argc, argv, "iiii", &x, &y, &width, &height RB_ARG_END);
GUARD_EXC( b->clearRect(x, y, width, height); ); GUARD_EXC(b->clearRect(x, y, width, height););
} }
return self; return self;
} }
RB_METHOD(bitmapBlur) RB_METHOD(bitmapBlur) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
@ -405,8 +371,7 @@ RB_METHOD(bitmapBlur)
return Qnil; return Qnil;
} }
RB_METHOD(bitmapRadialBlur) RB_METHOD(bitmapRadialBlur) {
{
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int angle, divisions; int angle, divisions;
@ -417,21 +382,19 @@ RB_METHOD(bitmapRadialBlur)
return Qnil; return Qnil;
} }
RB_METHOD(bitmapGetRawData) RB_METHOD(bitmapGetRawData) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
int size = b->width()*b->height()*4; int size = b->width() * b->height() * 4;
VALUE ret = rb_str_new(0, size); VALUE ret = rb_str_new(0, size);
GUARD_EXC ( b->getRaw(RSTRING_PTR(ret), size); ); GUARD_EXC(b->getRaw(RSTRING_PTR(ret), size););
return ret; return ret;
} }
RB_METHOD(bitmapSetRawData) RB_METHOD(bitmapSetRawData) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE str; VALUE str;
@ -440,13 +403,12 @@ RB_METHOD(bitmapSetRawData)
Bitmap *b = getPrivateData<Bitmap>(self); Bitmap *b = getPrivateData<Bitmap>(self);
GUARD_EXC( b->replaceRaw(RSTRING_PTR(str), RSTRING_LEN(str)); ); GUARD_EXC(b->replaceRaw(RSTRING_PTR(str), RSTRING_LEN(str)););
return self; return self;
} }
RB_METHOD(bitmapSaveToFile) RB_METHOD(bitmapSaveToFile) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE str; VALUE str;
@ -464,8 +426,7 @@ RB_METHOD(bitmapSaveToFile)
return RUBY_Qnil; return RUBY_Qnil;
} }
RB_METHOD(bitmapInitializeCopy) RB_METHOD(bitmapInitializeCopy) {
{
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
VALUE origObj = argv[0]; VALUE origObj = argv[0];
@ -474,7 +435,7 @@ RB_METHOD(bitmapInitializeCopy)
Bitmap *orig = getPrivateData<Bitmap>(origObj); Bitmap *orig = getPrivateData<Bitmap>(origObj);
Bitmap *b = 0; Bitmap *b = 0;
GUARD_EXC( b = new Bitmap(*orig); ); GUARD_EXC(b = new Bitmap(*orig););
bitmapInitProps(b, self); bitmapInitProps(b, self);
b->setFont(orig->getFont()); b->setFont(orig->getFont());
@ -484,12 +445,9 @@ RB_METHOD(bitmapInitializeCopy)
return self; return self;
} }
void bitmapBindingInit() {
void
bitmapBindingInit()
{
VALUE klass = rb_define_class("Bitmap", rb_cObject); VALUE klass = rb_define_class("Bitmap", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&BitmapType>); rb_define_alloc_func(klass, classAllocate<&BitmapType>);
#else #else
rb_define_alloc_func(klass, BitmapAllocate); rb_define_alloc_func(klass, BitmapAllocate);

270
binding/discord-binding.cpp
View file

@ -1,46 +1,39 @@
#include <discord_game_sdk.h> #include <discord_game_sdk.h>
#include "binding-types.h"
#include "binding-util.h"
#include "discordstate.h" #include "discordstate.h"
#include "sharedstate.h" #include "sharedstate.h"
#include "binding-util.h"
#include "binding-types.h"
//NYI // NYI
void discordResultCb(void *callback_data, enum EDiscordResult result) void discordResultCb(void *callback_data, enum EDiscordResult result) {}
{
} #if RAPI_FULL > 187
#ifndef OLD_RUBY
DEF_TYPE_CUSTOMFREE(DCActivity, free); DEF_TYPE_CUSTOMFREE(DCActivity, free);
#else #else
DEF_ALLOCFUNC_CUSTOMFREE(DCActivity, free); DEF_ALLOCFUNC_CUSTOMFREE(DCActivity, free);
#endif #endif
RB_METHOD(DiscordConnected) RB_METHOD(DiscordConnected) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
// Checking to make sure callbacks have actually fired // Checking to make sure callbacks have actually fired
return rb_bool_new(shState->discord().userId()); return rb_bool_new(shState->discord().userId());
} }
RB_METHOD(DiscordGetUsername) RB_METHOD(DiscordGetUsername) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userName().c_str()); return rb_str_new_cstr(shState->discord().userName().c_str());
} }
RB_METHOD(DiscordGetDiscriminator) RB_METHOD(DiscordGetDiscriminator) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userDiscrim().c_str()); return rb_str_new_cstr(shState->discord().userDiscrim().c_str());
} }
RB_METHOD(DiscordGetUserId) RB_METHOD(DiscordGetUserId) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return LL2NUM(shState->discord().userId()); return LL2NUM(shState->discord().userId());
@ -48,36 +41,34 @@ RB_METHOD(DiscordGetUserId)
void bitmapInitProps(Bitmap *b, VALUE self); void bitmapInitProps(Bitmap *b, VALUE self);
RB_METHOD(DiscordGetUserAvatar) RB_METHOD(DiscordGetUserAvatar) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
int size = 32; int size = 32;
rb_get_args(argc, argv, "|i", &size RB_ARG_END); rb_get_args(argc, argv, "|i", &size RB_ARG_END);
Bitmap *result = shState->discord().userAvatar(size); Bitmap *result = shState->discord().userAvatar(size);
if (!result) return RUBY_Qnil; if (!result)
return RUBY_Qnil;
VALUE ret = wrapObject(result, BitmapType); VALUE ret = wrapObject(result, BitmapType);
bitmapInitProps(result, ret); bitmapInitProps(result, ret);
return ret; return ret;
} }
RB_METHOD(DiscordActivitySend) RB_METHOD(DiscordActivitySend) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager(); IDiscordActivityManager *am = shState->discord().activityManager();
DiscordActivity *activity = getPrivateData<DiscordActivity>(self); DiscordActivity *activity = getPrivateData<DiscordActivity>(self);
if (am) am->update_activity(am, activity, 0, discordResultCb); if (am)
am->update_activity(am, activity, 0, discordResultCb);
return Qnil; return Qnil;
} }
RB_METHOD(DiscordActivityInitialize) RB_METHOD(DiscordActivityInitialize) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
DiscordActivity *activity = ALLOC(DiscordActivity); DiscordActivity *activity = ALLOC(DiscordActivity);
@ -87,16 +78,14 @@ RB_METHOD(DiscordActivityInitialize)
activity->type = DiscordActivityType_Playing; activity->type = DiscordActivityType_Playing;
if (rb_block_given_p()) if (rb_block_given_p()) {
{
rb_yield(self); rb_yield(self);
DiscordActivitySend(0, 0, self); DiscordActivitySend(0, 0, self);
}; };
return self; return self;
} }
RB_METHOD(DiscordActivityInitializeCopy) RB_METHOD(DiscordActivityInitializeCopy) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
@ -114,138 +103,124 @@ RB_METHOD(DiscordActivityInitializeCopy)
return self; return self;
} }
RB_METHOD(DiscordActivityClear) RB_METHOD(DiscordActivityClear) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager(); IDiscordActivityManager *am = shState->discord().activityManager();
if (am) am->clear_activity(am, 0, discordResultCb); if (am)
am->clear_activity(am, 0, discordResultCb);
return Qnil; return Qnil;
} }
#define DEF_DCPROP_ACTPARTYSZ(n) \ #define DEF_DCPROP_ACTPARTYSZ(n) \
RB_METHOD(DiscordActivityGetParty##n) \ RB_METHOD(DiscordActivityGetParty##n) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \ return INT2NUM(p->party.size.n); \
return INT2NUM(p->party.size.n); \ } \
} \ RB_METHOD(DiscordActivitySetParty##n) { \
RB_METHOD(DiscordActivitySetParty##n) \ RB_UNUSED_PARAM; \
{ \ int num; \
RB_UNUSED_PARAM; \ rb_get_args(argc, argv, "i", &num); \
int num; \ DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
rb_get_args(argc, argv, "i", &num); \ p->party.size.n = num; \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \ return INT2NUM(num); \
p->party.size.n = num; \ }
return INT2NUM(num); \
}
DEF_DCPROP_ACTPARTYSZ(current_size); DEF_DCPROP_ACTPARTYSZ(current_size);
DEF_DCPROP_ACTPARTYSZ(max_size); DEF_DCPROP_ACTPARTYSZ(max_size);
#define DEF_DCPROP_S(basename, propname, maxsz) \ #define DEF_DCPROP_S(basename, propname, maxsz) \
RB_METHOD(Discord##basename##Get##propname) \ RB_METHOD(Discord##basename##Get##propname) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return rb_str_new_cstr(p->propname); \
return rb_str_new_cstr(p->propname); \ } \
} \ RB_METHOD(Discord##basename##Set##propname) { \
RB_METHOD(Discord##basename##Set##propname) \ RB_UNUSED_PARAM; \
{ \ VALUE str; \
RB_UNUSED_PARAM; \ rb_scan_args(argc, argv, "1", &str); \
VALUE str; \ SafeStringValue(str); \
rb_scan_args(argc, argv, "1", &str); \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
SafeStringValue(str); \ strncpy(p->propname, RSTRING_PTR(str), maxsz); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return str; \
strncpy(p->propname, RSTRING_PTR(str), maxsz); \ }
return str; \
}
#define DEF_DCPROP_S_SUB(basename, subname, propname, maxsz) \ #define DEF_DCPROP_S_SUB(basename, subname, propname, maxsz) \
RB_METHOD(Discord##basename##Get##subname##_##propname) \ RB_METHOD(Discord##basename##Get##subname##_##propname) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return rb_str_new_cstr(p->subname.propname); \
return rb_str_new_cstr(p->subname.propname); \ } \
} \ RB_METHOD(Discord##basename##Set##subname##_##propname) { \
RB_METHOD(Discord##basename##Set##subname##_##propname) \ RB_UNUSED_PARAM; \
{ \ VALUE str; \
RB_UNUSED_PARAM; \ rb_scan_args(argc, argv, "1", &str); \
VALUE str; \ SafeStringValue(str); \
rb_scan_args(argc, argv, "1", &str); \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
SafeStringValue(str); \ strncpy(p->subname.propname, RSTRING_PTR(str), maxsz); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return str; \
strncpy(p->subname.propname, RSTRING_PTR(str), maxsz); \ }
return str; \
}
#define DEF_DCPROP_I(basename, propname, convtype, cast) \ #define DEF_DCPROP_I(basename, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##propname) \ RB_METHOD(Discord##basename##Get##propname) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return convtype##2NUM(p->propname); \
return convtype##2NUM(p->propname); \ } \
} \ RB_METHOD(Discord##basename##Set##propname) { \
RB_METHOD(Discord##basename##Set##propname) \ RB_UNUSED_PARAM; \
{ \ VALUE num; \
RB_UNUSED_PARAM; \ rb_scan_args(argc, argv, "1", &num); \
VALUE num; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
rb_scan_args(argc, argv, "1", &num); \ p->propname = (cast)NUM2##convtype(num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return num; \
p->propname = (cast)NUM2##convtype(num); \ }
return num; \
}
#define DEF_DCPROP_I_SUB(basename, subname, propname, convtype, cast) \ #define DEF_DCPROP_I_SUB(basename, subname, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##subname##_##propname) \ RB_METHOD(Discord##basename##Get##subname##_##propname) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return convtype##2NUM(p->subname.propname); \
return convtype##2NUM(p->subname.propname); \ } \
} \ RB_METHOD(Discord##basename##Set##subname##_##propname) { \
RB_METHOD(Discord##basename##Set##subname##_##propname) \ RB_UNUSED_PARAM; \
{ \ VALUE num; \
RB_UNUSED_PARAM; \ rb_scan_args(argc, argv, "1", &num); \
VALUE num; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
rb_scan_args(argc, argv, "1", &num); \ p->subname.propname = (cast)NUM2##convtype(num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return num; \
p->subname.propname = (cast)NUM2##convtype(num); \ }
return num; \
}
#define DEF_DCPROP_B(basename, propname) \ #define DEF_DCPROP_B(basename, propname) \
RB_METHOD(Discord##basename##Get##propname) \ RB_METHOD(Discord##basename##Get##propname) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return rb_bool_new(p->propname); \
return rb_bool_new(p->propname); \ } \
} \ RB_METHOD(Discord##basename##Set##propname) { \
RB_METHOD(Discord##basename##Set##propname) \ RB_UNUSED_PARAM; \
{ \ bool b; \
RB_UNUSED_PARAM; \ rb_get_args(argc, argv, "b", &b RB_ARG_END); \
bool b; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \ p->propname = b; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return rb_bool_new(b); \
p->propname = b; \ }
return rb_bool_new(b); \
}
#define DEF_DCPROP_B_SUB(basename, propname, subname) \ #define DEF_DCPROP_B_SUB(basename, propname, subname) \
RB_METHOD(Discord##basename##Get##propname) \ RB_METHOD(Discord##basename##Get##propname) { \
{ \ RB_UNUSED_PARAM; \
RB_UNUSED_PARAM; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return rb_bool_new(p->subname.propname); \
return rb_bool_new(p->subname.propname); \ } \
} \ RB_METHOD(Discord##basename##Set##propname) { \
RB_METHOD(Discord##basename##Set##propname) \ RB_UNUSED_PARAM; \
{ \ bool b; \
RB_UNUSED_PARAM; \ rb_get_args(argc, argv, "b", &b RB_ARG_END); \
bool b; \ Discord##basename *p = getPrivateData<Discord##basename>(self); \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \ p->subname.propname = b; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \ return rb_bool_new(b); \
p->subname.propname = b; \ }
return rb_bool_new(b); \
}
DEF_DCPROP_S(Activity, state, 128); DEF_DCPROP_S(Activity, state, 128);
DEF_DCPROP_S(Activity, details, 128); DEF_DCPROP_S(Activity, details, 128);
@ -261,28 +236,28 @@ DEF_DCPROP_I_SUB(Activity, timestamps, end, LL, DiscordTimestamp);
DEF_DCPROP_B(Activity, instance); DEF_DCPROP_B(Activity, instance);
#define BIND_DCPROP(basename, b, f) \ #define BIND_DCPROP(basename, b, f) \
_rb_define_method(activityClass, b, Discord##basename##Get##f); \ _rb_define_method(activityClass, b, Discord##basename##Get##f); \
_rb_define_method(activityClass, b "=", Discord##basename##Set##f); _rb_define_method(activityClass, b "=", Discord##basename##Set##f);
void DiscordBindingInit() {
void DiscordBindingInit()
{
VALUE mod = rb_define_module("Discord"); VALUE mod = rb_define_module("Discord");
_rb_define_module_function(mod, "connected?", DiscordConnected); _rb_define_module_function(mod, "connected?", DiscordConnected);
_rb_define_module_function(mod, "user_name", DiscordGetUsername); _rb_define_module_function(mod, "user_name", DiscordGetUsername);
_rb_define_module_function(mod, "user_discriminator", DiscordGetDiscriminator); _rb_define_module_function(mod, "user_discriminator",
DiscordGetDiscriminator);
_rb_define_module_function(mod, "user_id", DiscordGetUserId); _rb_define_module_function(mod, "user_id", DiscordGetUserId);
_rb_define_module_function(mod, "user_avatar", DiscordGetUserAvatar); _rb_define_module_function(mod, "user_avatar", DiscordGetUserAvatar);
VALUE activityClass = rb_define_class_under(mod, "Activity", rb_cObject); VALUE activityClass = rb_define_class_under(mod, "Activity", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(activityClass, classAllocate<&DCActivityType>); rb_define_alloc_func(activityClass, classAllocate<&DCActivityType>);
#else #else
rb_define_alloc_func(activityClass, DCActivityAllocate); rb_define_alloc_func(activityClass, DCActivityAllocate);
#endif #endif
_rb_define_method(activityClass, "initialize", DiscordActivityInitialize); _rb_define_method(activityClass, "initialize", DiscordActivityInitialize);
_rb_define_method(activityClass, "initialize_copy", DiscordActivityInitializeCopy); _rb_define_method(activityClass, "initialize_copy",
DiscordActivityInitializeCopy);
rb_define_class_method(activityClass, "clear", DiscordActivityClear); rb_define_class_method(activityClass, "clear", DiscordActivityClear);
@ -302,5 +277,4 @@ void DiscordBindingInit()
BIND_DCPROP(Activity, "start_time", timestamps_start); BIND_DCPROP(Activity, "start_time", timestamps_start);
BIND_DCPROP(Activity, "end_time", timestamps_end); BIND_DCPROP(Activity, "end_time", timestamps_end);
BIND_DCPROP(Activity, "instance", instance); BIND_DCPROP(Activity, "instance", instance);
} }

128
binding/etc-binding.cpp
View file

@ -19,12 +19,12 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "etc.h"
#include "binding-util.h" #include "binding-util.h"
#include "etc.h"
#include "serializable-binding.h" #include "serializable-binding.h"
#include "sharedstate.h" #include "sharedstate.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Color); DEF_TYPE(Color);
DEF_TYPE(Tone); DEF_TYPE(Tone);
DEF_TYPE(Rect); DEF_TYPE(Rect);
@ -35,14 +35,12 @@ DEF_ALLOCFUNC(Rect);
#endif #endif
#define ATTR_RW(Klass, Attr, arg_type, arg_t_s, value_fun) \ #define ATTR_RW(Klass, Attr, arg_type, arg_t_s, value_fun) \
RB_METHOD(Klass##Get##Attr) \ RB_METHOD(Klass##Get##Attr) { \
{ \
RB_UNUSED_PARAM \ RB_UNUSED_PARAM \
Klass *p = getPrivateData<Klass>(self); \ Klass *p = getPrivateData<Klass>(self); \
return value_fun(p->get##Attr()); \ return value_fun(p->get##Attr()); \
} \ } \
RB_METHOD(Klass##Set##Attr) \ RB_METHOD(Klass##Set##Attr) { \
{ \
Klass *p = getPrivateData<Klass>(self); \ Klass *p = getPrivateData<Klass>(self); \
arg_type arg; \ arg_type arg; \
rb_get_args(argc, argv, arg_t_s, &arg RB_ARG_END); \ rb_get_args(argc, argv, arg_t_s, &arg RB_ARG_END); \
@ -50,7 +48,8 @@ DEF_ALLOCFUNC(Rect);
return *argv; \ return *argv; \
} }
#define ATTR_DOUBLE_RW(Klass, Attr) ATTR_RW(Klass, Attr, double, "f", rb_float_new) #define ATTR_DOUBLE_RW(Klass, Attr) \
ATTR_RW(Klass, Attr, double, "f", rb_float_new)
#define ATTR_INT_RW(Klass, Attr) ATTR_RW(Klass, Attr, int, "i", rb_fix_new) #define ATTR_INT_RW(Klass, Attr) ATTR_RW(Klass, Attr, int, "i", rb_fix_new)
ATTR_DOUBLE_RW(Color, Red) ATTR_DOUBLE_RW(Color, Red)
@ -68,10 +67,9 @@ ATTR_INT_RW(Rect, Y)
ATTR_INT_RW(Rect, Width) ATTR_INT_RW(Rect, Width)
ATTR_INT_RW(Rect, Height) ATTR_INT_RW(Rect, Height)
#ifndef OLD_RUBY #if RAPI_FULL > 187
#define EQUAL_FUN(Klass) \ #define EQUAL_FUN(Klass) \
RB_METHOD(Klass##Equal) \ RB_METHOD(Klass##Equal) { \
{ \
Klass *p = getPrivateData<Klass>(self); \ Klass *p = getPrivateData<Klass>(self); \
VALUE otherObj; \ VALUE otherObj; \
Klass *other; \ Klass *other; \
@ -84,8 +82,7 @@ ATTR_INT_RW(Rect, Height)
} }
#else #else
#define EQUAL_FUN(Klass) \ #define EQUAL_FUN(Klass) \
RB_METHOD(Klass##Equal) \ RB_METHOD(Klass##Equal) { \
{ \
Klass *p = getPrivateData<Klass>(self); \ Klass *p = getPrivateData<Klass>(self); \
VALUE otherObj; \ VALUE otherObj; \
Klass *other; \ Klass *other; \
@ -101,15 +98,11 @@ EQUAL_FUN(Tone)
EQUAL_FUN(Rect) EQUAL_FUN(Rect)
#define INIT_FUN(Klass, param_type, param_t_s, last_param_def) \ #define INIT_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Initialize) \ RB_METHOD(Klass##Initialize) { \
{ \
Klass *k; \ Klass *k; \
if (argc == 0) \ if (argc == 0) { \
{ \
k = new Klass(); \ k = new Klass(); \
} \ } else { \
else \
{ \
param_type p1, p2, p3, p4 = last_param_def; \ param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \ rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k = new Klass(p1, p2, p3, p4); \ k = new Klass(p1, p2, p3, p4); \
@ -122,19 +115,15 @@ INIT_FUN(Color, double, "fff|f", 255)
INIT_FUN(Tone, double, "fff|f", 0) INIT_FUN(Tone, double, "fff|f", 0)
INIT_FUN(Rect, int, "iiii", 0) INIT_FUN(Rect, int, "iiii", 0)
#ifndef OLD_RUBY #if RAPI_FULL > 187
#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \ #define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Set) \ RB_METHOD(Klass##Set) { \
{ \
Klass *k = getPrivateData<Klass>(self); \ Klass *k = getPrivateData<Klass>(self); \
if (argc == 1) \ if (argc == 1) { \
{ \
VALUE otherObj = argv[0]; \ VALUE otherObj = argv[0]; \
Klass *other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \ Klass *other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \
*k = *other; \ *k = *other; \
} \ } else { \
else \
{ \
param_type p1, p2, p3, p4 = last_param_def; \ param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \ rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k->set(p1, p2, p3, p4); \ k->set(p1, p2, p3, p4); \
@ -143,17 +132,13 @@ INIT_FUN(Rect, int, "iiii", 0)
} }
#else #else
#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \ #define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Set) \ RB_METHOD(Klass##Set) { \
{ \
Klass *k = getPrivateData<Klass>(self); \ Klass *k = getPrivateData<Klass>(self); \
if (argc == 1) \ if (argc == 1) { \
{ \
VALUE otherObj = argv[0]; \ VALUE otherObj = argv[0]; \
Klass *other = getPrivateDataCheck<Klass>(otherObj, #Klass); \ Klass *other = getPrivateDataCheck<Klass>(otherObj, #Klass); \
*k = *other; \ *k = *other; \
} \ } else { \
else \
{ \
param_type p1, p2, p3, p4 = last_param_def; \ param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \ rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k->set(p1, p2, p3, p4); \ k->set(p1, p2, p3, p4); \
@ -166,63 +151,53 @@ SET_FUN(Color, double, "fff|f", 255)
SET_FUN(Tone, double, "fff|f", 0) SET_FUN(Tone, double, "fff|f", 0)
SET_FUN(Rect, int, "iiii", 0) SET_FUN(Rect, int, "iiii", 0)
RB_METHOD(rectEmpty) RB_METHOD(rectEmpty) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Rect *r = getPrivateData<Rect>(self); Rect *r = getPrivateData<Rect>(self);
r->empty(); r->empty();
return self; return self;
} }
RB_METHOD(ColorStringify) RB_METHOD(ColorStringify) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Color *c = getPrivateData<Color>(self); Color *c = getPrivateData<Color>(self);
#ifndef OLD_RUBY #if RAPI_FULL > 187
return rb_sprintf("(%f, %f, %f, %f)", return rb_sprintf("(%f, %f, %f, %f)", c->red, c->green, c->blue, c->alpha);
c->red, c->green, c->blue, c->alpha);
#else #else
char buf[50] = {0}; char buf[50] = {0};
sprintf((char*)&buf, "(%f, %f, %f, %f)", sprintf((char *)&buf, "(%f, %f, %f, %f)", c->red, c->green, c->blue,
c->red, c->green, c->blue, c->alpha); c->alpha);
return rb_str_new2(buf); return rb_str_new2(buf);
#endif #endif
} }
RB_METHOD(ToneStringify) RB_METHOD(ToneStringify) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Tone *t = getPrivateData<Tone>(self); Tone *t = getPrivateData<Tone>(self);
#ifndef OLD_RUBY #if RAPI_FULL > 187
return rb_sprintf("(%f, %f, %f, %f)", return rb_sprintf("(%f, %f, %f, %f)", t->red, t->green, t->blue, t->gray);
t->red, t->green, t->blue, t->gray);
#else #else
char buf[50] = {0}; char buf[50] = {0};
sprintf((char*)&buf, "(%f, %f, %f, %f)", sprintf((char *)&buf, "(%f, %f, %f, %f)", t->red, t->green, t->blue, t->gray);
t->red, t->green, t->blue, t->gray);
return rb_str_new2(buf); return rb_str_new2(buf);
#endif #endif
} }
RB_METHOD(RectStringify) RB_METHOD(RectStringify) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Rect *r = getPrivateData<Rect>(self); Rect *r = getPrivateData<Rect>(self);
#ifndef OLD_RUBY #if RAPI_FULL > 187
return rb_sprintf("(%d, %d, %d, %d)", return rb_sprintf("(%d, %d, %d, %d)", r->x, r->y, r->width, r->height);
r->x, r->y, r->width, r->height);
#else #else
char buf[50] = {0}; char buf[50] = {0};
sprintf((char*)&buf, "(%d, %d, %d, %d)", sprintf((char *)&buf, "(%d, %d, %d, %d)", r->x, r->y, r->width, r->height);
r->x, r->y, r->width, r->height);
return rb_str_new2(buf); return rb_str_new2(buf);
#endif #endif
} }
MARSH_LOAD_FUN(Color) MARSH_LOAD_FUN(Color)
@ -233,9 +208,9 @@ INITCOPY_FUN(Tone)
INITCOPY_FUN(Color) INITCOPY_FUN(Color)
INITCOPY_FUN(Rect) INITCOPY_FUN(Rect)
#ifndef OLD_RUBY #if RAPI_FULL > 187
#define INIT_BIND(Klass) \ #define INIT_BIND(Klass) \
{ \ { \
klass = rb_define_class(#Klass, rb_cObject); \ klass = rb_define_class(#Klass, rb_cObject); \
rb_define_alloc_func(klass, classAllocate<&Klass##Type>); \ rb_define_alloc_func(klass, classAllocate<&Klass##Type>); \
rb_define_class_method(klass, "_load", Klass##Load); \ rb_define_class_method(klass, "_load", Klass##Load); \
@ -248,10 +223,10 @@ INITCOPY_FUN(Rect)
_rb_define_method(klass, "eql?", Klass##Equal); \ _rb_define_method(klass, "eql?", Klass##Equal); \
_rb_define_method(klass, "to_s", Klass##Stringify); \ _rb_define_method(klass, "to_s", Klass##Stringify); \
_rb_define_method(klass, "inspect", Klass##Stringify); \ _rb_define_method(klass, "inspect", Klass##Stringify); \
} }
#else #else
#define INIT_BIND(Klass) \ #define INIT_BIND(Klass) \
{ \ { \
klass = rb_define_class(#Klass, rb_cObject); \ klass = rb_define_class(#Klass, rb_cObject); \
rb_define_alloc_func(klass, Klass##Allocate); \ rb_define_alloc_func(klass, Klass##Allocate); \
rb_define_class_method(klass, "_load", Klass##Load); \ rb_define_class_method(klass, "_load", Klass##Load); \
@ -264,21 +239,30 @@ INITCOPY_FUN(Rect)
_rb_define_method(klass, "eql?", Klass##Equal); \ _rb_define_method(klass, "eql?", Klass##Equal); \
_rb_define_method(klass, "to_s", Klass##Stringify); \ _rb_define_method(klass, "to_s", Klass##Stringify); \
_rb_define_method(klass, "inspect", Klass##Stringify); \ _rb_define_method(klass, "inspect", Klass##Stringify); \
} }
#endif #endif
#define MRB_ATTR_R(Class, attr) mrb_define_method(mrb, klass, #attr, Class##Get_##attr, MRB_ARGS_NONE()) #define MRB_ATTR_R(Class, attr) \
#define MRB_ATTR_W(Class, attr) mrb_define_method(mrb, klass, #attr "=", Class##Set_##attr, MRB_ARGS_REQ(1)) mrb_define_method(mrb, klass, #attr, Class##Get_##attr, MRB_ARGS_NONE())
#define MRB_ATTR_RW(Class, attr) { MRB_ATTR_R(Class, attr); MRB_ATTR_W(Class, attr); } #define MRB_ATTR_W(Class, attr) \
mrb_define_method(mrb, klass, #attr "=", Class##Set_##attr, MRB_ARGS_REQ(1))
#define MRB_ATTR_RW(Class, attr) \
{ \
MRB_ATTR_R(Class, attr); \
MRB_ATTR_W(Class, attr); \
}
#define RB_ATTR_R(Klass, Attr, attr) _rb_define_method(klass, #attr, Klass##Get##Attr) #define RB_ATTR_R(Klass, Attr, attr) \
#define RB_ATTR_W(Klass, Attr, attr) _rb_define_method(klass, #attr "=", Klass##Set##Attr) _rb_define_method(klass, #attr, Klass##Get##Attr)
#define RB_ATTR_W(Klass, Attr, attr) \
_rb_define_method(klass, #attr "=", Klass##Set##Attr)
#define RB_ATTR_RW(Klass, Attr, attr) \ #define RB_ATTR_RW(Klass, Attr, attr) \
{ RB_ATTR_R(Klass, Attr, attr); RB_ATTR_W(Klass, Attr, attr); } { \
RB_ATTR_R(Klass, Attr, attr); \
RB_ATTR_W(Klass, Attr, attr); \
}
void void etcBindingInit() {
etcBindingInit()
{
VALUE klass; VALUE klass;
INIT_BIND(Color); INIT_BIND(Color);

24
binding/filesystem-binding.cpp
View file

@ -26,7 +26,7 @@
#include "src/config.h" #include "src/config.h"
#include "src/util.h" #include "src/util.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
#include "ruby/encoding.h" #include "ruby/encoding.h"
#include "ruby/intern.h" #include "ruby/intern.h"
#else #else
@ -40,7 +40,7 @@ static void fileIntFreeInstance(void *inst) {
SDL_FreeRW(ops); SDL_FreeRW(ops);
} }
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE_CUSTOMFREE(FileInt, fileIntFreeInstance); DEF_TYPE_CUSTOMFREE(FileInt, fileIntFreeInstance);
#else #else
DEF_ALLOCFUNC_CUSTOMFREE(FileInt, fileIntFreeInstance); DEF_ALLOCFUNC_CUSTOMFREE(FileInt, fileIntFreeInstance);
@ -200,8 +200,8 @@ RB_METHOD(kernelSaveData) {
return Qnil; return Qnil;
} }
#ifndef OLD_RUBY #if RAPI_FULL > 187
#if RUBYCOMPAT < 270 #if RAPI_FULL < 270
static VALUE stringForceUTF8(VALUE arg) static VALUE stringForceUTF8(VALUE arg)
#else #else
static VALUE stringForceUTF8(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, arg)) static VALUE stringForceUTF8(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, arg))
@ -213,7 +213,7 @@ static VALUE stringForceUTF8(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, arg))
return arg; return arg;
} }
#if RUBYCOMPAT < 270 #if RAPI_FULL < 270
static VALUE customProc(VALUE arg, VALUE proc) { static VALUE customProc(VALUE arg, VALUE proc) {
VALUE obj = stringForceUTF8(arg); VALUE obj = stringForceUTF8(arg);
obj = rb_funcall2(proc, rb_intern("call"), 1, &obj); obj = rb_funcall2(proc, rb_intern("call"), 1, &obj);
@ -224,7 +224,7 @@ static VALUE customProc(VALUE arg, VALUE proc) {
RB_METHOD(_marshalLoad) { RB_METHOD(_marshalLoad) {
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
#if RUBYCOMPAT < 270 #if RAPI_FULL < 270
VALUE port, proc = Qnil; VALUE port, proc = Qnil;
rb_get_args(argc, argv, "o|o", &port, &proc RB_ARG_END); rb_get_args(argc, argv, "o|o", &port, &proc RB_ARG_END);
#else #else
@ -233,7 +233,7 @@ RB_METHOD(_marshalLoad) {
#endif #endif
VALUE utf8Proc; VALUE utf8Proc;
#if RUBYCOMPAT < 270 #if RAPI_FULL < 270
if (NIL_P(proc)) if (NIL_P(proc))
utf8Proc = rb_proc_new(RUBY_METHOD_FUNC(stringForceUTF8), Qnil); utf8Proc = rb_proc_new(RUBY_METHOD_FUNC(stringForceUTF8), Qnil);
@ -250,9 +250,9 @@ RB_METHOD(_marshalLoad) {
} }
#endif #endif
void fileIntBindingInit() { void fileIntBindingInit() {
VALUE klass = rb_define_class("FileInt", rb_cIO); VALUE klass = rb_define_class("FileInt", rb_cIO);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&FileIntType>); rb_define_alloc_func(klass, classAllocate<&FileIntType>);
#else #else
rb_define_alloc_func(klass, FileIntAllocate); rb_define_alloc_func(klass, FileIntAllocate);
@ -260,7 +260,7 @@ RB_METHOD(_marshalLoad) {
_rb_define_method(klass, "read", fileIntRead); _rb_define_method(klass, "read", fileIntRead);
_rb_define_method(klass, "getbyte", fileIntGetByte); _rb_define_method(klass, "getbyte", fileIntGetByte);
#ifdef OLD_RUBY #if RAPI_FULL <= 187
// Ruby doesn't see this as an initialized stream, // Ruby doesn't see this as an initialized stream,
// so either that has to be fixed or necessary // so either that has to be fixed or necessary
// IO functions have to be overridden // IO functions have to be overridden
@ -273,7 +273,7 @@ RB_METHOD(_marshalLoad) {
_rb_define_module_function(rb_mKernel, "load_data", kernelLoadData); _rb_define_module_function(rb_mKernel, "load_data", kernelLoadData);
_rb_define_module_function(rb_mKernel, "save_data", kernelSaveData); _rb_define_module_function(rb_mKernel, "save_data", kernelSaveData);
#ifndef OLD_RUBY #if RAPI_FULL > 187
/* We overload the built-in 'Marshal::load()' function to silently /* We overload the built-in 'Marshal::load()' function to silently
* insert our utf8proc that ensures all read strings will be * insert our utf8proc that ensures all read strings will be
* UTF-8 encoded */ * UTF-8 encoded */
@ -281,4 +281,4 @@ RB_METHOD(_marshalLoad) {
rb_define_alias(rb_singleton_class(marsh), "_mkxp_load_alias", "load"); rb_define_alias(rb_singleton_class(marsh), "_mkxp_load_alias", "load");
_rb_define_module_function(marsh, "load", _marshalLoad); _rb_define_module_function(marsh, "load", _marshalLoad);
#endif #endif
} }

103
binding/font-binding.cpp
View file

@ -19,26 +19,19 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "font.h"
#include "binding-util.h"
#include "binding-types.h" #include "binding-types.h"
#include "binding-util.h"
#include "exception.h" #include "exception.h"
#include "font.h"
#include "sharedstate.h" #include "sharedstate.h"
#include <string.h> #include <string.h>
static void collectStrings(VALUE obj, std::vector<std::string> &out) {
static void if (RB_TYPE_P(obj, RUBY_T_STRING)) {
collectStrings(VALUE obj, std::vector<std::string> &out)
{
if (RB_TYPE_P(obj, RUBY_T_STRING))
{
out.push_back(RSTRING_PTR(obj)); out.push_back(RSTRING_PTR(obj));
} } else if (RB_TYPE_P(obj, RUBY_T_ARRAY)) {
else if (RB_TYPE_P(obj, RUBY_T_ARRAY)) for (long i = 0; i < RARRAY_LEN(obj); ++i) {
{
for (long i = 0; i < RARRAY_LEN(obj); ++i)
{
VALUE str = rb_ary_entry(obj, i); VALUE str = rb_ary_entry(obj, i);
/* Non-string objects are tolerated (ignored) */ /* Non-string objects are tolerated (ignored) */
@ -50,14 +43,13 @@ collectStrings(VALUE obj, std::vector<std::string> &out)
} }
} }
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Font); DEF_TYPE(Font);
#else #else
DEF_ALLOCFUNC(Font); DEF_ALLOCFUNC(Font);
#endif #endif
RB_METHOD(fontDoesExist) RB_METHOD(fontDoesExist) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
const char *name = 0; const char *name = 0;
@ -73,8 +65,7 @@ RB_METHOD(fontDoesExist)
RB_METHOD(FontSetName); RB_METHOD(FontSetName);
RB_METHOD(fontInitialize) RB_METHOD(fontInitialize) {
{
VALUE namesObj = Qnil; VALUE namesObj = Qnil;
int size = 0; int size = 0;
@ -82,13 +73,10 @@ RB_METHOD(fontInitialize)
Font *f; Font *f;
if (NIL_P(namesObj)) if (NIL_P(namesObj)) {
{
namesObj = rb_iv_get(rb_obj_class(self), "default_name"); namesObj = rb_iv_get(rb_obj_class(self), "default_name");
f = new Font(0, size); f = new Font(0, size);
} } else {
else
{
std::vector<std::string> names; std::vector<std::string> names;
collectStrings(namesObj, names); collectStrings(namesObj, names);
@ -113,8 +101,7 @@ RB_METHOD(fontInitialize)
return self; return self;
} }
RB_METHOD(fontInitializeCopy) RB_METHOD(fontInitializeCopy) {
{
VALUE origObj; VALUE origObj;
rb_get_args(argc, argv, "o", &origObj RB_ARG_END); rb_get_args(argc, argv, "o", &origObj RB_ARG_END);
@ -136,15 +123,13 @@ RB_METHOD(fontInitializeCopy)
return self; return self;
} }
RB_METHOD(FontGetName) RB_METHOD(FontGetName) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_iv_get(self, "name"); return rb_iv_get(self, "name");
} }
RB_METHOD(FontSetName) RB_METHOD(FontSetName) {
{
Font *f = getPrivateData<Font>(self); Font *f = getPrivateData<Font>(self);
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
@ -158,8 +143,7 @@ RB_METHOD(FontSetName)
return argv[0]; return argv[0];
} }
template<class C> template <class C> static void checkDisposed(VALUE) {}
static void checkDisposed(VALUE) {}
DEF_PROP_OBJ_VAL(Font, Color, Color, "color") DEF_PROP_OBJ_VAL(Font, Color, Color, "color")
DEF_PROP_OBJ_VAL(Font, Color, OutColor, "out_color") DEF_PROP_OBJ_VAL(Font, Color, OutColor, "out_color")
@ -172,13 +156,11 @@ DEF_PROP_B(Font, Shadow)
DEF_PROP_B(Font, Outline) DEF_PROP_B(Font, Outline)
#define DEF_KLASS_PROP(Klass, type, PropName, param_t_s, value_fun) \ #define DEF_KLASS_PROP(Klass, type, PropName, param_t_s, value_fun) \
RB_METHOD(Klass##Get##PropName) \ RB_METHOD(Klass##Get##PropName) { \
{ \
RB_UNUSED_PARAM; \ RB_UNUSED_PARAM; \
return value_fun(Klass::get##PropName()); \ return value_fun(Klass::get##PropName()); \
} \ } \
RB_METHOD(Klass##Set##PropName) \ RB_METHOD(Klass##Set##PropName) { \
{ \
RB_UNUSED_PARAM; \ RB_UNUSED_PARAM; \
type value; \ type value; \
rb_get_args(argc, argv, param_t_s, &value RB_ARG_END); \ rb_get_args(argc, argv, param_t_s, &value RB_ARG_END); \
@ -192,14 +174,12 @@ DEF_KLASS_PROP(Font, bool, DefaultItalic, "b", rb_bool_new)
DEF_KLASS_PROP(Font, bool, DefaultShadow, "b", rb_bool_new) DEF_KLASS_PROP(Font, bool, DefaultShadow, "b", rb_bool_new)
DEF_KLASS_PROP(Font, bool, DefaultOutline, "b", rb_bool_new) DEF_KLASS_PROP(Font, bool, DefaultOutline, "b", rb_bool_new)
RB_METHOD(FontGetDefaultOutColor) RB_METHOD(FontGetDefaultOutColor) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_iv_get(self, "default_out_color"); return rb_iv_get(self, "default_out_color");
} }
RB_METHOD(FontSetDefaultOutColor) RB_METHOD(FontSetDefaultOutColor) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE colorObj; VALUE colorObj;
@ -212,15 +192,13 @@ RB_METHOD(FontSetDefaultOutColor)
return colorObj; return colorObj;
} }
RB_METHOD(FontGetDefaultName) RB_METHOD(FontGetDefaultName) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_iv_get(self, "default_name"); return rb_iv_get(self, "default_name");
} }
RB_METHOD(FontSetDefaultName) RB_METHOD(FontSetDefaultName) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
@ -234,15 +212,12 @@ RB_METHOD(FontSetDefaultName)
return argv[0]; return argv[0];
} }
RB_METHOD(FontGetDefaultColor) RB_METHOD(FontGetDefaultColor) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_iv_get(self, "default_color"); return rb_iv_get(self, "default_color");
} }
RB_METHOD(FontSetDefaultColor) {
RB_METHOD(FontSetDefaultColor)
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE colorObj; VALUE colorObj;
@ -256,16 +231,14 @@ RB_METHOD(FontSetDefaultColor)
} }
#define INIT_KLASS_PROP_BIND(Klass, PropName, prop_name_s) \ #define INIT_KLASS_PROP_BIND(Klass, PropName, prop_name_s) \
{ \ { \
rb_define_class_method(klass, prop_name_s, Klass##Get##PropName); \ rb_define_class_method(klass, prop_name_s, Klass##Get##PropName); \
rb_define_class_method(klass, prop_name_s "=", Klass##Set##PropName); \ rb_define_class_method(klass, prop_name_s "=", Klass##Set##PropName); \
} }
void void fontBindingInit() {
fontBindingInit()
{
VALUE klass = rb_define_class("Font", rb_cObject); VALUE klass = rb_define_class("Font", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&FontType>); rb_define_alloc_func(klass, classAllocate<&FontType>);
#else #else
rb_define_alloc_func(klass, FontAllocate); rb_define_alloc_func(klass, FontAllocate);
@ -278,12 +251,9 @@ fontBindingInit()
const std::vector<std::string> &defNames = Font::getInitialDefaultNames(); const std::vector<std::string> &defNames = Font::getInitialDefaultNames();
VALUE defNamesObj; VALUE defNamesObj;
if (defNames.size() == 1) if (defNames.size() == 1) {
{
defNamesObj = rb_str_new_cstr(defNames[0].c_str()); defNamesObj = rb_str_new_cstr(defNames[0].c_str());
} } else {
else
{
defNamesObj = rb_ary_new2(defNames.size()); defNamesObj = rb_ary_new2(defNames.size());
for (size_t i = 0; i < defNames.size(); ++i) for (size_t i = 0; i < defNames.size(); ++i)
@ -293,7 +263,8 @@ fontBindingInit()
rb_iv_set(klass, "default_name", defNamesObj); rb_iv_set(klass, "default_name", defNamesObj);
if (rgssVer >= 3) if (rgssVer >= 3)
wrapProperty(klass, &Font::getDefaultOutColor(), "default_out_color", ColorType); wrapProperty(klass, &Font::getDefaultOutColor(), "default_out_color",
ColorType);
INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name"); INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size"); INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");
@ -301,13 +272,11 @@ fontBindingInit()
INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic"); INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic");
INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color"); INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color");
if (rgssVer >= 2) if (rgssVer >= 2) {
{
INIT_KLASS_PROP_BIND(Font, DefaultShadow, "default_shadow"); INIT_KLASS_PROP_BIND(Font, DefaultShadow, "default_shadow");
} }
if (rgssVer >= 3) if (rgssVer >= 3) {
{
INIT_KLASS_PROP_BIND(Font, DefaultOutline, "default_outline"); INIT_KLASS_PROP_BIND(Font, DefaultOutline, "default_outline");
INIT_KLASS_PROP_BIND(Font, DefaultOutColor, "default_out_color"); INIT_KLASS_PROP_BIND(Font, DefaultOutColor, "default_out_color");
} }
@ -323,13 +292,11 @@ fontBindingInit()
INIT_PROP_BIND(Font, Italic, "italic"); INIT_PROP_BIND(Font, Italic, "italic");
INIT_PROP_BIND(Font, Color, "color"); INIT_PROP_BIND(Font, Color, "color");
if (rgssVer >= 2) if (rgssVer >= 2) {
{
INIT_PROP_BIND(Font, Shadow, "shadow"); INIT_PROP_BIND(Font, Shadow, "shadow");
} }
if (rgssVer >= 3) if (rgssVer >= 3) {
{
INIT_PROP_BIND(Font, Outline, "outline"); INIT_PROP_BIND(Font, Outline, "outline");
INIT_PROP_BIND(Font, OutColor, "out_color"); INIT_PROP_BIND(Font, OutColor, "out_color");
} }

182
binding/input-binding.cpp
View file

@ -19,17 +19,16 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "binding-util.h"
#include "exception.h"
#include "input.h" #include "input.h"
#include "sharedstate.h" #include "sharedstate.h"
#include "exception.h"
#include "binding-util.h"
#include "src/util.h" #include "src/util.h"
#include <string>
#include <SDL_joystick.h> #include <SDL_joystick.h>
#include <string>
RB_METHOD(inputUpdate) RB_METHOD(inputUpdate) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
shState->input().update(); shState->input().update();
@ -37,18 +36,14 @@ RB_METHOD(inputUpdate)
return Qnil; return Qnil;
} }
static int getButtonArg(VALUE *argv) static int getButtonArg(VALUE *argv) {
{
int num; int num;
if (FIXNUM_P(*argv)) if (FIXNUM_P(*argv)) {
{
num = FIX2INT(*argv); num = FIX2INT(*argv);
} } else if (SYMBOL_P(*argv) && rgssVer >= 3) {
else if (SYMBOL_P(*argv) && rgssVer >= 3)
{
VALUE symHash = getRbData()->buttoncodeHash; VALUE symHash = getRbData()->buttoncodeHash;
#ifndef OLD_RUBY #if RAPI_FULL > 187
num = FIX2INT(rb_hash_lookup2(symHash, *argv, INT2FIX(Input::None))); num = FIX2INT(rb_hash_lookup2(symHash, *argv, INT2FIX(Input::None)));
#else #else
VALUE res = rb_hash_aref(symHash, *argv); VALUE res = rb_hash_aref(symHash, *argv);
@ -57,9 +52,7 @@ static int getButtonArg(VALUE *argv)
else else
num = Input::None; num = Input::None;
#endif #endif
} } else {
else
{
// FIXME: RMXP allows only few more types that // FIXME: RMXP allows only few more types that
// don't make sense (symbols in pre 3, floats) // don't make sense (symbols in pre 3, floats)
num = 0; num = 0;
@ -68,24 +61,19 @@ static int getButtonArg(VALUE *argv)
return num; return num;
} }
static int getScancodeArg(VALUE *argv) static int getScancodeArg(VALUE *argv) {
{
const char *scancode = rb_id2name(SYM2ID(*argv)); const char *scancode = rb_id2name(SYM2ID(*argv));
int code{}; int code{};
try try {
{
code = strToScancode[scancode]; code = strToScancode[scancode];
} } catch (...) {
catch (...)
{
rb_raise(rb_eRuntimeError, "%s is not a valid key.", scancode); rb_raise(rb_eRuntimeError, "%s is not a valid key.", scancode);
} }
return code; return code;
} }
RB_METHOD(inputPress) RB_METHOD(inputPress) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
@ -95,8 +83,7 @@ RB_METHOD(inputPress)
int num{}; int num{};
if (SYMBOL_P(button)) if (SYMBOL_P(button)) {
{
num = getScancodeArg(&button); num = getScancodeArg(&button);
return rb_bool_new(shState->input().isPressedEx(num, 0)); return rb_bool_new(shState->input().isPressedEx(num, 0));
} }
@ -106,8 +93,7 @@ RB_METHOD(inputPress)
return rb_bool_new(shState->input().isPressed(num)); return rb_bool_new(shState->input().isPressed(num));
} }
RB_METHOD(inputTrigger) RB_METHOD(inputTrigger) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
@ -117,8 +103,7 @@ RB_METHOD(inputTrigger)
int num{}; int num{};
if (SYMBOL_P(button)) if (SYMBOL_P(button)) {
{
num = getScancodeArg(&button); num = getScancodeArg(&button);
return rb_bool_new(shState->input().isTriggeredEx(num, 0)); return rb_bool_new(shState->input().isTriggeredEx(num, 0));
} }
@ -128,8 +113,7 @@ RB_METHOD(inputTrigger)
return rb_bool_new(shState->input().isTriggered(num)); return rb_bool_new(shState->input().isTriggered(num));
} }
RB_METHOD(inputRepeat) RB_METHOD(inputRepeat) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
rb_check_argc(argc, 1); rb_check_argc(argc, 1);
@ -139,8 +123,7 @@ RB_METHOD(inputRepeat)
int num{}; int num{};
if (SYMBOL_P(button)) if (SYMBOL_P(button)) {
{
num = getScancodeArg(&button); num = getScancodeArg(&button);
return rb_bool_new(shState->input().isRepeatedEx(num, 0)); return rb_bool_new(shState->input().isRepeatedEx(num, 0));
} }
@ -150,8 +133,7 @@ RB_METHOD(inputRepeat)
return rb_bool_new(shState->input().isRepeated(num)); return rb_bool_new(shState->input().isRepeated(num));
} }
RB_METHOD(inputPressEx) RB_METHOD(inputPressEx) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
int num; int num;
@ -160,8 +142,7 @@ RB_METHOD(inputPressEx)
return rb_bool_new(shState->input().isPressedEx(num, 1)); return rb_bool_new(shState->input().isPressedEx(num, 1));
} }
RB_METHOD(inputTriggerEx) RB_METHOD(inputTriggerEx) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
int num; int num;
@ -170,8 +151,7 @@ RB_METHOD(inputTriggerEx)
return rb_bool_new(shState->input().isTriggeredEx(num, 1)); return rb_bool_new(shState->input().isTriggeredEx(num, 1));
} }
RB_METHOD(inputRepeatEx) RB_METHOD(inputRepeatEx) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
int num; int num;
@ -180,43 +160,38 @@ RB_METHOD(inputRepeatEx)
return rb_bool_new(shState->input().isRepeatedEx(num, 1)); return rb_bool_new(shState->input().isRepeatedEx(num, 1));
} }
RB_METHOD(inputDir4) RB_METHOD(inputDir4) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_fix_new(shState->input().dir4Value()); return rb_fix_new(shState->input().dir4Value());
} }
RB_METHOD(inputDir8) RB_METHOD(inputDir8) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_fix_new(shState->input().dir8Value()); return rb_fix_new(shState->input().dir8Value());
} }
/* Non-standard extensions */ /* Non-standard extensions */
RB_METHOD(inputMouseX) RB_METHOD(inputMouseX) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_fix_new(shState->input().mouseX()); return rb_fix_new(shState->input().mouseX());
} }
RB_METHOD(inputMouseY) RB_METHOD(inputMouseY) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_fix_new(shState->input().mouseY()); return rb_fix_new(shState->input().mouseY());
} }
#define M_SYMBOL(x) ID2SYM(rb_intern(x)) #define M_SYMBOL(x) ID2SYM(rb_intern(x))
#define POWERCASE(v,c) \ #define POWERCASE(v, c) \
case SDL_JOYSTICK_POWER_##c: \ case SDL_JOYSTICK_POWER_##c: \
v = M_SYMBOL(#c); \ v = M_SYMBOL(#c); \
break; break;
RB_METHOD(inputJoystickInfo) RB_METHOD(inputJoystickInfo) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
if (!shState->input().getJoystickConnected()) if (!shState->input().getJoystickConnected())
@ -224,7 +199,8 @@ RB_METHOD(inputJoystickInfo)
VALUE ret = rb_hash_new(); VALUE ret = rb_hash_new();
rb_hash_aset(ret, M_SYMBOL("name"), rb_str_new_cstr(shState->input().getJoystickName())); rb_hash_aset(ret, M_SYMBOL("name"),
rb_str_new_cstr(shState->input().getJoystickName()));
VALUE power; VALUE power;
@ -243,13 +219,11 @@ RB_METHOD(inputJoystickInfo)
rb_hash_aset(ret, M_SYMBOL("power"), power); rb_hash_aset(ret, M_SYMBOL("power"), power);
return ret; return ret;
} }
#undef POWERCASE #undef POWERCASE
#undef M_SYMBOL #undef M_SYMBOL
RB_METHOD(inputRumble) RB_METHOD(inputRumble) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE duration, strength, attack, fade; VALUE duration, strength, attack, fade;
rb_scan_args(argc, argv, "13", &duration, &strength, &attack, &fade); rb_scan_args(argc, argv, "13", &duration, &strength, &attack, &fade);
@ -264,15 +238,13 @@ RB_METHOD(inputRumble)
return Qnil; return Qnil;
} }
RB_METHOD(inputGetMode) RB_METHOD(inputGetMode) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_bool_new(shState->input().getTextInputMode()); return rb_bool_new(shState->input().getTextInputMode());
} }
RB_METHOD(inputSetMode) RB_METHOD(inputSetMode) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
bool mode; bool mode;
@ -283,8 +255,7 @@ RB_METHOD(inputSetMode)
return mode; return mode;
} }
RB_METHOD(inputGets) RB_METHOD(inputGets) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE ret = rb_str_new_cstr(shState->input().getText()); VALUE ret = rb_str_new_cstr(shState->input().getText());
@ -293,8 +264,7 @@ RB_METHOD(inputGets)
return ret; return ret;
} }
RB_METHOD(inputGetClipboard) RB_METHOD(inputGetClipboard) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE ret; VALUE ret;
try { try {
@ -305,8 +275,7 @@ RB_METHOD(inputGetClipboard)
return ret; return ret;
} }
RB_METHOD(inputSetClipboard) RB_METHOD(inputSetClipboard) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
VALUE str; VALUE str;
@ -322,54 +291,46 @@ RB_METHOD(inputSetClipboard)
return str; return str;
} }
struct {
struct
{
const char *str; const char *str;
Input::ButtonCode val; Input::ButtonCode val;
} } static buttonCodes[] = {{"DOWN", Input::Down},
static buttonCodes[] = {"LEFT", Input::Left},
{ {"RIGHT", Input::Right},
{ "DOWN", Input::Down }, {"UP", Input::Up},
{ "LEFT", Input::Left },
{ "RIGHT", Input::Right },
{ "UP", Input::Up },
#ifdef MARIN #ifdef MARIN
{ "ZL", Input::ZL }, {"ZL", Input::ZL},
{ "ZR", Input::ZR }, {"ZR", Input::ZR},
#else #else
{ "C", Input::ZL }, {"C", Input::ZL},
{ "Z", Input::ZR }, {"Z", Input::ZR},
#endif #endif
{ "A", Input::A }, {"A", Input::A},
{ "B", Input::B }, {"B", Input::B},
{ "X", Input::X }, {"X", Input::X},
{ "Y", Input::Y }, {"Y", Input::Y},
{ "L", Input::L }, {"L", Input::L},
{ "R", Input::R }, {"R", Input::R},
{ "SHIFT", Input::Shift }, {"SHIFT", Input::Shift},
{ "CTRL", Input::Ctrl }, {"CTRL", Input::Ctrl},
{ "ALT", Input::Alt }, {"ALT", Input::Alt},
{ "F5", Input::F5 }, {"F5", Input::F5},
{ "F6", Input::F6 }, {"F6", Input::F6},
{ "F7", Input::F7 }, {"F7", Input::F7},
{ "F8", Input::F8 }, {"F8", Input::F8},
{ "F9", Input::F9 }, {"F9", Input::F9},
{ "MOUSELEFT", Input::MouseLeft }, {"MOUSELEFT", Input::MouseLeft},
{ "MOUSEMIDDLE", Input::MouseMiddle }, {"MOUSEMIDDLE", Input::MouseMiddle},
{ "MOUSERIGHT", Input::MouseRight } {"MOUSERIGHT", Input::MouseRight}};
};
static elementsN(buttonCodes); static elementsN(buttonCodes);
void void inputBindingInit() {
inputBindingInit()
{
VALUE module = rb_define_module("Input"); VALUE module = rb_define_module("Input");
_rb_define_module_function(module, "update", inputUpdate); _rb_define_module_function(module, "update", inputUpdate);
@ -395,12 +356,10 @@ inputBindingInit()
_rb_define_module_function(module, "clipboard", inputGetClipboard); _rb_define_module_function(module, "clipboard", inputGetClipboard);
_rb_define_module_function(module, "clipboard=", inputSetClipboard); _rb_define_module_function(module, "clipboard=", inputSetClipboard);
if (rgssVer >= 3) if (rgssVer >= 3) {
{
VALUE symHash = rb_hash_new(); VALUE symHash = rb_hash_new();
for (size_t i = 0; i < buttonCodesN; ++i) for (size_t i = 0; i < buttonCodesN; ++i) {
{
ID sym = rb_intern(buttonCodes[i].str); ID sym = rb_intern(buttonCodes[i].str);
VALUE val = INT2FIX(buttonCodes[i].val); VALUE val = INT2FIX(buttonCodes[i].val);
@ -412,11 +371,8 @@ inputBindingInit()
rb_iv_set(module, "buttoncodes", symHash); rb_iv_set(module, "buttoncodes", symHash);
getRbData()->buttoncodeHash = symHash; getRbData()->buttoncodeHash = symHash;
} } else {
else for (size_t i = 0; i < buttonCodesN; ++i) {
{
for (size_t i = 0; i < buttonCodesN; ++i)
{
ID sym = rb_intern(buttonCodes[i].str); ID sym = rb_intern(buttonCodes[i].str);
VALUE val = INT2FIX(buttonCodes[i].val); VALUE val = INT2FIX(buttonCodes[i].val);

7
binding/meson.build
View file

@ -1,11 +1,8 @@
if get_option('mri_includes') == '' if get_option('mri_includes') == ''
ver = get_option('mri_version') ver = get_option('mri_version')
if ver.version_compare('>1.8') == false if ver.version_compare('<=1.9')
add_project_arguments('-DOLD_RUBY', language: ['cpp','objc','objcpp']) global_args += '-DLEGACY_RUBY'
endif
if ver.version_compare('>=2.7') == true
add_project_arguments('-DRUBYCOMPAT=270', language: ['cpp', 'objc', 'objcpp'])
endif endif
global_dependencies += dependency('ruby-' + ver) global_dependencies += dependency('ruby-' + ver)
else else

4
binding/miniffi-binding.cpp
View file

@ -36,7 +36,7 @@ typedef PREFABI void *(*MINIFFI_FUNC)(unsigned long, unsigned long,
// MiniFFI class, also named Win32API on Windows // MiniFFI class, also named Win32API on Windows
// Uses LoadLibrary/GetProcAddress on Windows, dlopen/dlsym everywhere else // Uses LoadLibrary/GetProcAddress on Windows, dlopen/dlsym everywhere else
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE_CUSTOMFREE(MiniFFI, SDL_UnloadObject); DEF_TYPE_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
#else #else
DEF_ALLOCFUNC_CUSTOMFREE(MiniFFI, SDL_UnloadObject); DEF_ALLOCFUNC_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
@ -308,7 +308,7 @@ RB_METHOD(MiniFFI_call) {
void MiniFFIBindingInit() { void MiniFFIBindingInit() {
VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject); VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>); rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>);
#else #else
rb_define_alloc_func(cMiniFFI, MiniFFIAllocate); rb_define_alloc_func(cMiniFFI, MiniFFIAllocate);

40
binding/plane-binding.cpp
View file

@ -19,20 +19,19 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "plane.h"
#include "disposable-binding.h"
#include "viewportelement-binding.h"
#include "binding-util.h"
#include "binding-types.h" #include "binding-types.h"
#include "binding-util.h"
#include "disposable-binding.h"
#include "plane.h"
#include "viewportelement-binding.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Plane); DEF_TYPE(Plane);
#else #else
DEF_ALLOCFUNC(Plane); DEF_ALLOCFUNC(Plane);
#endif #endif
RB_METHOD(planeInitialize) RB_METHOD(planeInitialize) {
{
Plane *p = viewportElementInitialize<Plane>(argc, argv, self); Plane *p = viewportElementInitialize<Plane>(argc, argv, self);
setPrivateData(self, p); setPrivateData(self, p);
@ -57,29 +56,26 @@ DEF_PROP_I(Plane, BlendType)
DEF_PROP_F(Plane, ZoomX) DEF_PROP_F(Plane, ZoomX)
DEF_PROP_F(Plane, ZoomY) DEF_PROP_F(Plane, ZoomY)
void planeBindingInit() {
void
planeBindingInit()
{
VALUE klass = rb_define_class("Plane", rb_cObject); VALUE klass = rb_define_class("Plane", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&PlaneType>); rb_define_alloc_func(klass, classAllocate<&PlaneType>);
#else #else
rb_define_alloc_func(klass, PlaneAllocate); rb_define_alloc_func(klass, PlaneAllocate);
#endif #endif
disposableBindingInit<Plane> (klass); disposableBindingInit<Plane>(klass);
viewportElementBindingInit<Plane>(klass); viewportElementBindingInit<Plane>(klass);
_rb_define_method(klass, "initialize", planeInitialize); _rb_define_method(klass, "initialize", planeInitialize);
INIT_PROP_BIND( Plane, Bitmap, "bitmap" ); INIT_PROP_BIND(Plane, Bitmap, "bitmap");
INIT_PROP_BIND( Plane, OX, "ox" ); INIT_PROP_BIND(Plane, OX, "ox");
INIT_PROP_BIND( Plane, OY, "oy" ); INIT_PROP_BIND(Plane, OY, "oy");
INIT_PROP_BIND( Plane, ZoomX, "zoom_x" ); INIT_PROP_BIND(Plane, ZoomX, "zoom_x");
INIT_PROP_BIND( Plane, ZoomY, "zoom_y" ); INIT_PROP_BIND(Plane, ZoomY, "zoom_y");
INIT_PROP_BIND( Plane, Opacity, "opacity" ); INIT_PROP_BIND(Plane, Opacity, "opacity");
INIT_PROP_BIND( Plane, BlendType, "blend_type" ); INIT_PROP_BIND(Plane, BlendType, "blend_type");
INIT_PROP_BIND( Plane, Color, "color" ); INIT_PROP_BIND(Plane, Color, "color");
INIT_PROP_BIND( Plane, Tone, "tone" ); INIT_PROP_BIND(Plane, Tone, "tone");
} }

76
binding/sprite-binding.cpp
View file

@ -19,23 +19,22 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "sprite.h" #include "binding-types.h"
#include "sharedstate.h" #include "binding-util.h"
#include "disposable-binding.h" #include "disposable-binding.h"
#include "flashable-binding.h" #include "flashable-binding.h"
#include "sceneelement-binding.h" #include "sceneelement-binding.h"
#include "sharedstate.h"
#include "sprite.h"
#include "viewportelement-binding.h" #include "viewportelement-binding.h"
#include "binding-util.h"
#include "binding-types.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Sprite); DEF_TYPE(Sprite);
#else #else
DEF_ALLOCFUNC(Sprite); DEF_ALLOCFUNC(Sprite);
#endif #endif
RB_METHOD(spriteInitialize) RB_METHOD(spriteInitialize) {
{
Sprite *s = viewportElementInitialize<Sprite>(argc, argv, self); Sprite *s = viewportElementInitialize<Sprite>(argc, argv, self);
setPrivateData(self, s); setPrivateData(self, s);
@ -74,72 +73,67 @@ DEF_PROP_F(Sprite, WavePhase)
DEF_PROP_B(Sprite, Mirror) DEF_PROP_B(Sprite, Mirror)
RB_METHOD(spriteWidth) RB_METHOD(spriteWidth) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Sprite *s = getPrivateData<Sprite>(self); Sprite *s = getPrivateData<Sprite>(self);
int value = 0; int value = 0;
GUARD_EXC( value = s->getWidth(); ) GUARD_EXC(value = s->getWidth();)
return rb_fix_new(value); return rb_fix_new(value);
} }
RB_METHOD(spriteHeight) RB_METHOD(spriteHeight) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Sprite *s = getPrivateData<Sprite>(self); Sprite *s = getPrivateData<Sprite>(self);
int value = 0; int value = 0;
GUARD_EXC( value = s->getHeight(); ) GUARD_EXC(value = s->getHeight();)
return rb_fix_new(value); return rb_fix_new(value);
} }
void void spriteBindingInit() {
spriteBindingInit()
{
VALUE klass = rb_define_class("Sprite", rb_cObject); VALUE klass = rb_define_class("Sprite", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&SpriteType>); rb_define_alloc_func(klass, classAllocate<&SpriteType>);
#else #else
rb_define_alloc_func(klass, SpriteAllocate); rb_define_alloc_func(klass, SpriteAllocate);
#endif #endif
disposableBindingInit <Sprite>(klass); disposableBindingInit<Sprite>(klass);
flashableBindingInit <Sprite>(klass); flashableBindingInit<Sprite>(klass);
viewportElementBindingInit<Sprite>(klass); viewportElementBindingInit<Sprite>(klass);
_rb_define_method(klass, "initialize", spriteInitialize); _rb_define_method(klass, "initialize", spriteInitialize);
INIT_PROP_BIND( Sprite, Bitmap, "bitmap" ); INIT_PROP_BIND(Sprite, Bitmap, "bitmap");
INIT_PROP_BIND( Sprite, SrcRect, "src_rect" ); INIT_PROP_BIND(Sprite, SrcRect, "src_rect");
INIT_PROP_BIND( Sprite, X, "x" ); INIT_PROP_BIND(Sprite, X, "x");
INIT_PROP_BIND( Sprite, Y, "y" ); INIT_PROP_BIND(Sprite, Y, "y");
INIT_PROP_BIND( Sprite, OX, "ox" ); INIT_PROP_BIND(Sprite, OX, "ox");
INIT_PROP_BIND( Sprite, OY, "oy" ); INIT_PROP_BIND(Sprite, OY, "oy");
INIT_PROP_BIND( Sprite, ZoomX, "zoom_x" ); INIT_PROP_BIND(Sprite, ZoomX, "zoom_x");
INIT_PROP_BIND( Sprite, ZoomY, "zoom_y" ); INIT_PROP_BIND(Sprite, ZoomY, "zoom_y");
INIT_PROP_BIND( Sprite, Angle, "angle" ); INIT_PROP_BIND(Sprite, Angle, "angle");
INIT_PROP_BIND( Sprite, Mirror, "mirror" ); INIT_PROP_BIND(Sprite, Mirror, "mirror");
INIT_PROP_BIND( Sprite, BushDepth, "bush_depth" ); INIT_PROP_BIND(Sprite, BushDepth, "bush_depth");
INIT_PROP_BIND( Sprite, Opacity, "opacity" ); INIT_PROP_BIND(Sprite, Opacity, "opacity");
INIT_PROP_BIND( Sprite, BlendType, "blend_type" ); INIT_PROP_BIND(Sprite, BlendType, "blend_type");
INIT_PROP_BIND( Sprite, Color, "color" ); INIT_PROP_BIND(Sprite, Color, "color");
INIT_PROP_BIND( Sprite, Tone, "tone" ); INIT_PROP_BIND(Sprite, Tone, "tone");
if (rgssVer >= 2) if (rgssVer >= 2) {
{
_rb_define_method(klass, "width", spriteWidth); _rb_define_method(klass, "width", spriteWidth);
_rb_define_method(klass, "height", spriteHeight); _rb_define_method(klass, "height", spriteHeight);
INIT_PROP_BIND( Sprite, BushOpacity, "bush_opacity" ); INIT_PROP_BIND(Sprite, BushOpacity, "bush_opacity");
INIT_PROP_BIND( Sprite, WaveAmp, "wave_amp" ); INIT_PROP_BIND(Sprite, WaveAmp, "wave_amp");
INIT_PROP_BIND( Sprite, WaveLength, "wave_length" ); INIT_PROP_BIND(Sprite, WaveLength, "wave_length");
INIT_PROP_BIND( Sprite, WaveSpeed, "wave_speed" ); INIT_PROP_BIND(Sprite, WaveSpeed, "wave_speed");
INIT_PROP_BIND( Sprite, WavePhase, "wave_phase" ); INIT_PROP_BIND(Sprite, WavePhase, "wave_phase");
} }
} }

52
binding/table-binding.cpp
View file

@ -19,23 +19,20 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <algorithm>
#include "table.h"
#include "binding-util.h" #include "binding-util.h"
#include "serializable-binding.h" #include "serializable-binding.h"
#include "table.h"
#include <algorithm>
static int num2TableSize(VALUE v) static int num2TableSize(VALUE v) {
{
int i = NUM2INT(v); int i = NUM2INT(v);
return std::max(0, i); return std::max(0, i);
} }
static void parseArgsTableSizes(int argc, VALUE *argv, int *x, int *y, int *z) static void parseArgsTableSizes(int argc, VALUE *argv, int *x, int *y, int *z) {
{
*y = *z = 1; *y = *z = 1;
switch (argc) switch (argc) {
{
case 3: case 3:
*z = num2TableSize(argv[2]); *z = num2TableSize(argv[2]);
/* fall through */ /* fall through */
@ -49,14 +46,13 @@ static void parseArgsTableSizes(int argc, VALUE *argv, int *x, int *y, int *z)
rb_error_arity(argc, 1, 3); rb_error_arity(argc, 1, 3);
} }
} }
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Table); DEF_TYPE(Table);
#else #else
DEF_ALLOCFUNC(Table); DEF_ALLOCFUNC(Table);
#endif #endif
RB_METHOD(tableInitialize) RB_METHOD(tableInitialize) {
{
int x, y, z; int x, y, z;
parseArgsTableSizes(argc, argv, &x, &y, &z); parseArgsTableSizes(argc, argv, &x, &y, &z);
@ -68,8 +64,7 @@ RB_METHOD(tableInitialize)
return self; return self;
} }
RB_METHOD(tableResize) RB_METHOD(tableResize) {
{
Table *t = getPrivateData<Table>(self); Table *t = getPrivateData<Table>(self);
int x, y, z; int x, y, z;
@ -81,8 +76,7 @@ RB_METHOD(tableResize)
} }
#define TABLE_SIZE(d, D) \ #define TABLE_SIZE(d, D) \
RB_METHOD(table##D##Size) \ RB_METHOD(table##D##Size) { \
{ \
RB_UNUSED_PARAM \ RB_UNUSED_PARAM \
Table *t = getPrivateData<Table>(self); \ Table *t = getPrivateData<Table>(self); \
return INT2NUM(t->d##Size()); \ return INT2NUM(t->d##Size()); \
@ -92,8 +86,7 @@ TABLE_SIZE(x, X)
TABLE_SIZE(y, Y) TABLE_SIZE(y, Y)
TABLE_SIZE(z, Z) TABLE_SIZE(z, Z)
RB_METHOD(tableGetAt) RB_METHOD(tableGetAt) {
{
Table *t = getPrivateData<Table>(self); Table *t = getPrivateData<Table>(self);
int x, y, z; int x, y, z;
@ -108,10 +101,8 @@ RB_METHOD(tableGetAt)
if (argc > 3) if (argc > 3)
rb_raise(rb_eArgError, "wrong number of arguments"); rb_raise(rb_eArgError, "wrong number of arguments");
if (x < 0 || x >= t->xSize() if (x < 0 || x >= t->xSize() || y < 0 || y >= t->ySize() || z < 0 ||
|| y < 0 || y >= t->ySize() z >= t->zSize()) {
|| z < 0 || z >= t->zSize())
{
return Qnil; return Qnil;
} }
@ -120,8 +111,7 @@ RB_METHOD(tableGetAt)
return INT2FIX(result); /* short always fits in a Fixnum */ return INT2FIX(result); /* short always fits in a Fixnum */
} }
RB_METHOD(tableSetAt) RB_METHOD(tableSetAt) {
{
Table *t = getPrivateData<Table>(self); Table *t = getPrivateData<Table>(self);
int x, y, z, value; int x, y, z, value;
@ -130,21 +120,20 @@ RB_METHOD(tableSetAt)
if (argc < 2) if (argc < 2)
rb_raise(rb_eArgError, "wrong number of arguments"); rb_raise(rb_eArgError, "wrong number of arguments");
switch (argc) switch (argc) {
{
default: default:
case 2 : case 2:
x = NUM2INT(argv[0]); x = NUM2INT(argv[0]);
value = NUM2INT(argv[1]); value = NUM2INT(argv[1]);
break; break;
case 3 : case 3:
x = NUM2INT(argv[0]); x = NUM2INT(argv[0]);
y = NUM2INT(argv[1]); y = NUM2INT(argv[1]);
value = NUM2INT(argv[2]); value = NUM2INT(argv[2]);
break; break;
case 4 : case 4:
x = NUM2INT(argv[0]); x = NUM2INT(argv[0]);
y = NUM2INT(argv[1]); y = NUM2INT(argv[1]);
z = NUM2INT(argv[2]); z = NUM2INT(argv[2]);
@ -161,11 +150,9 @@ RB_METHOD(tableSetAt)
MARSH_LOAD_FUN(Table) MARSH_LOAD_FUN(Table)
INITCOPY_FUN(Table) INITCOPY_FUN(Table)
void void tableBindingInit() {
tableBindingInit()
{
VALUE klass = rb_define_class("Table", rb_cObject); VALUE klass = rb_define_class("Table", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TableType>); rb_define_alloc_func(klass, classAllocate<&TableType>);
#else #else
rb_define_alloc_func(klass, TableAllocate); rb_define_alloc_func(klass, TableAllocate);
@ -183,5 +170,4 @@ tableBindingInit()
_rb_define_method(klass, "zsize", tableZSize); _rb_define_method(klass, "zsize", tableZSize);
_rb_define_method(klass, "[]", tableGetAt); _rb_define_method(klass, "[]", tableGetAt);
_rb_define_method(klass, "[]=", tableSetAt); _rb_define_method(klass, "[]=", tableSetAt);
} }

54
binding/tilemap-binding.cpp
View file

@ -19,23 +19,22 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "tilemap.h"
#include "viewport.h"
#include "bitmap.h" #include "bitmap.h"
#include "table.h" #include "table.h"
#include "tilemap.h"
#include "viewport.h"
#include "disposable-binding.h"
#include "binding-util.h"
#include "binding-types.h" #include "binding-types.h"
#include "binding-util.h"
#include "disposable-binding.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE_CUSTOMFREE(TilemapAutotiles, RUBY_TYPED_NEVER_FREE); DEF_TYPE_CUSTOMFREE(TilemapAutotiles, RUBY_TYPED_NEVER_FREE);
#else #else
#define TilemapAutotilesType "TilemapAutotiles" #define TilemapAutotilesType "TilemapAutotiles"
#endif #endif
RB_METHOD(tilemapAutotilesSet) RB_METHOD(tilemapAutotilesSet) {
{
Tilemap::Autotiles *a = getPrivateData<Tilemap::Autotiles>(self); Tilemap::Autotiles *a = getPrivateData<Tilemap::Autotiles>(self);
int i; int i;
@ -53,10 +52,9 @@ RB_METHOD(tilemapAutotilesSet)
return self; return self;
} }
RB_METHOD(tilemapAutotilesGet) RB_METHOD(tilemapAutotilesGet) {
{
int i; int i;
rb_get_args (argc, argv, "i", &i RB_ARG_END); rb_get_args(argc, argv, "i", &i RB_ARG_END);
if (i < 0 || i > 6) if (i < 0 || i > 6)
return Qnil; return Qnil;
@ -66,14 +64,13 @@ RB_METHOD(tilemapAutotilesGet)
return rb_ary_entry(ary, i); return rb_ary_entry(ary, i);
} }
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Tilemap); DEF_TYPE(Tilemap);
#else #else
DEF_ALLOCFUNC(Tilemap); DEF_ALLOCFUNC(Tilemap);
#endif #endif
RB_METHOD(tilemapInitialize) RB_METHOD(tilemapInitialize) {
{
Tilemap *t; Tilemap *t;
/* Get parameters */ /* Get parameters */
@ -109,8 +106,7 @@ RB_METHOD(tilemapInitialize)
return self; return self;
} }
RB_METHOD(tilemapGetAutotiles) RB_METHOD(tilemapGetAutotiles) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
checkDisposed<Tilemap>(self); checkDisposed<Tilemap>(self);
@ -118,8 +114,7 @@ RB_METHOD(tilemapGetAutotiles)
return rb_iv_get(self, "autotiles"); return rb_iv_get(self, "autotiles");
} }
RB_METHOD(tilemapUpdate) RB_METHOD(tilemapUpdate) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Tilemap *t = getPrivateData<Tilemap>(self); Tilemap *t = getPrivateData<Tilemap>(self);
@ -129,8 +124,7 @@ RB_METHOD(tilemapUpdate)
return Qnil; return Qnil;
} }
RB_METHOD(tilemapGetViewport) RB_METHOD(tilemapGetViewport) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
checkDisposed<Tilemap>(self); checkDisposed<Tilemap>(self);
@ -148,11 +142,9 @@ DEF_PROP_B(Tilemap, Visible)
DEF_PROP_I(Tilemap, OX) DEF_PROP_I(Tilemap, OX)
DEF_PROP_I(Tilemap, OY) DEF_PROP_I(Tilemap, OY)
void void tilemapBindingInit() {
tilemapBindingInit()
{
VALUE klass = rb_define_class("TilemapAutotiles", rb_cObject); VALUE klass = rb_define_class("TilemapAutotiles", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TilemapAutotilesType>); rb_define_alloc_func(klass, classAllocate<&TilemapAutotilesType>);
#endif #endif
@ -160,7 +152,7 @@ tilemapBindingInit()
_rb_define_method(klass, "[]", tilemapAutotilesGet); _rb_define_method(klass, "[]", tilemapAutotilesGet);
klass = rb_define_class("Tilemap", rb_cObject); klass = rb_define_class("Tilemap", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TilemapType>); rb_define_alloc_func(klass, classAllocate<&TilemapType>);
#else #else
rb_define_alloc_func(klass, TilemapAllocate); rb_define_alloc_func(klass, TilemapAllocate);
@ -174,11 +166,11 @@ tilemapBindingInit()
_rb_define_method(klass, "viewport", tilemapGetViewport); _rb_define_method(klass, "viewport", tilemapGetViewport);
INIT_PROP_BIND( Tilemap, Tileset, "tileset" ); INIT_PROP_BIND(Tilemap, Tileset, "tileset");
INIT_PROP_BIND( Tilemap, MapData, "map_data" ); INIT_PROP_BIND(Tilemap, MapData, "map_data");
INIT_PROP_BIND( Tilemap, FlashData, "flash_data" ); INIT_PROP_BIND(Tilemap, FlashData, "flash_data");
INIT_PROP_BIND( Tilemap, Priorities, "priorities" ); INIT_PROP_BIND(Tilemap, Priorities, "priorities");
INIT_PROP_BIND( Tilemap, Visible, "visible" ); INIT_PROP_BIND(Tilemap, Visible, "visible");
INIT_PROP_BIND( Tilemap, OX, "ox" ); INIT_PROP_BIND(Tilemap, OX, "ox");
INIT_PROP_BIND( Tilemap, OY, "oy" ); INIT_PROP_BIND(Tilemap, OY, "oy");
} }

60
binding/tilemapvx-binding.cpp
View file

@ -19,17 +19,17 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "bitmap.h"
#include "sharedstate.h"
#include "table.h"
#include "tilemapvx.h" #include "tilemapvx.h"
#include "viewport.h" #include "viewport.h"
#include "bitmap.h"
#include "table.h"
#include "sharedstate.h"
#include "disposable-binding.h"
#include "binding-util.h"
#include "binding-types.h" #include "binding-types.h"
#include "binding-util.h"
#include "disposable-binding.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE_CUSTOMNAME(TilemapVX, "Tilemap"); DEF_TYPE_CUSTOMNAME(TilemapVX, "Tilemap");
DEF_TYPE_CUSTOMFREE(BitmapArray, RUBY_TYPED_NEVER_FREE); DEF_TYPE_CUSTOMFREE(BitmapArray, RUBY_TYPED_NEVER_FREE);
@ -38,8 +38,7 @@ DEF_ALLOCFUNC(TilemapVX);
#define BitmapArrayType "BitmapArray" #define BitmapArrayType "BitmapArray"
#endif #endif
RB_METHOD(tilemapVXInitialize) RB_METHOD(tilemapVXInitialize) {
{
TilemapVX *t; TilemapVX *t;
/* Get parameters */ /* Get parameters */
@ -76,8 +75,7 @@ RB_METHOD(tilemapVXInitialize)
return self; return self;
} }
RB_METHOD(tilemapVXGetBitmapArray) RB_METHOD(tilemapVXGetBitmapArray) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
checkDisposed<TilemapVX>(self); checkDisposed<TilemapVX>(self);
@ -85,8 +83,7 @@ RB_METHOD(tilemapVXGetBitmapArray)
return rb_iv_get(self, "bitmap_array"); return rb_iv_get(self, "bitmap_array");
} }
RB_METHOD(tilemapVXUpdate) RB_METHOD(tilemapVXUpdate) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
TilemapVX *t = getPrivateData<TilemapVX>(self); TilemapVX *t = getPrivateData<TilemapVX>(self);
@ -106,8 +103,7 @@ DEF_PROP_B(TilemapVX, Visible)
DEF_PROP_I(TilemapVX, OX) DEF_PROP_I(TilemapVX, OX)
DEF_PROP_I(TilemapVX, OY) DEF_PROP_I(TilemapVX, OY)
RB_METHOD(tilemapVXBitmapsSet) RB_METHOD(tilemapVXBitmapsSet) {
{
TilemapVX::BitmapArray *a = getPrivateData<TilemapVX::BitmapArray>(self); TilemapVX::BitmapArray *a = getPrivateData<TilemapVX::BitmapArray>(self);
int i; int i;
@ -125,10 +121,9 @@ RB_METHOD(tilemapVXBitmapsSet)
return self; return self;
} }
RB_METHOD(tilemapVXBitmapsGet) RB_METHOD(tilemapVXBitmapsGet) {
{
int i; int i;
rb_get_args (argc, argv, "i", &i RB_ARG_END); rb_get_args(argc, argv, "i", &i RB_ARG_END);
if (i < 0 || i > 8) if (i < 0 || i > 8)
return Qnil; return Qnil;
@ -138,11 +133,9 @@ RB_METHOD(tilemapVXBitmapsGet)
return rb_ary_entry(ary, i); return rb_ary_entry(ary, i);
} }
void void tilemapVXBindingInit() {
tilemapVXBindingInit()
{
VALUE klass = rb_define_class("Tilemap", rb_cObject); VALUE klass = rb_define_class("Tilemap", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TilemapVXType>); rb_define_alloc_func(klass, classAllocate<&TilemapVXType>);
#else #else
rb_define_alloc_func(klass, TilemapVXAllocate); rb_define_alloc_func(klass, TilemapVXAllocate);
@ -154,24 +147,21 @@ tilemapVXBindingInit()
_rb_define_method(klass, "bitmaps", tilemapVXGetBitmapArray); _rb_define_method(klass, "bitmaps", tilemapVXGetBitmapArray);
_rb_define_method(klass, "update", tilemapVXUpdate); _rb_define_method(klass, "update", tilemapVXUpdate);
INIT_PROP_BIND( TilemapVX, Viewport, "viewport" ); INIT_PROP_BIND(TilemapVX, Viewport, "viewport");
INIT_PROP_BIND( TilemapVX, MapData, "map_data" ); INIT_PROP_BIND(TilemapVX, MapData, "map_data");
INIT_PROP_BIND( TilemapVX, FlashData, "flash_data" ); INIT_PROP_BIND(TilemapVX, FlashData, "flash_data");
INIT_PROP_BIND( TilemapVX, Visible, "visible" ); INIT_PROP_BIND(TilemapVX, Visible, "visible");
INIT_PROP_BIND( TilemapVX, OX, "ox" ); INIT_PROP_BIND(TilemapVX, OX, "ox");
INIT_PROP_BIND( TilemapVX, OY, "oy" ); INIT_PROP_BIND(TilemapVX, OY, "oy");
if (rgssVer == 3) if (rgssVer == 3) {
{ INIT_PROP_BIND(TilemapVX, Flags, "flags");
INIT_PROP_BIND( TilemapVX, Flags, "flags" ); } else {
} INIT_PROP_BIND(TilemapVX, Flags, "passages");
else
{
INIT_PROP_BIND( TilemapVX, Flags, "passages" );
} }
klass = rb_define_class_under(klass, "BitmapArray", rb_cObject); klass = rb_define_class_under(klass, "BitmapArray", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&BitmapArrayType>); rb_define_alloc_func(klass, classAllocate<&BitmapArrayType>);
#endif #endif

46
binding/viewport-binding.cpp
View file

@ -19,30 +19,26 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "viewport.h" #include "binding-types.h"
#include "sharedstate.h" #include "binding-util.h"
#include "disposable-binding.h" #include "disposable-binding.h"
#include "flashable-binding.h" #include "flashable-binding.h"
#include "sceneelement-binding.h" #include "sceneelement-binding.h"
#include "binding-util.h" #include "sharedstate.h"
#include "binding-types.h" #include "viewport.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Viewport); DEF_TYPE(Viewport);
#else #else
DEF_ALLOCFUNC(Viewport); DEF_ALLOCFUNC(Viewport);
#endif #endif
RB_METHOD(viewportInitialize) RB_METHOD(viewportInitialize) {
{
Viewport *v; Viewport *v;
if (argc == 0 && rgssVer >= 3) if (argc == 0 && rgssVer >= 3) {
{
v = new Viewport(); v = new Viewport();
} } else if (argc == 1) {
else if (argc == 1)
{
/* The rect arg is only used to init the viewport, /* The rect arg is only used to init the viewport,
* and does NOT replace its 'rect' property */ * and does NOT replace its 'rect' property */
VALUE rectObj; VALUE rectObj;
@ -53,9 +49,7 @@ RB_METHOD(viewportInitialize)
rect = getPrivateDataCheck<Rect>(rectObj, RectType); rect = getPrivateDataCheck<Rect>(rectObj, RectType);
v = new Viewport(rect); v = new Viewport(rect);
} } else {
else
{
int x, y, width, height; int x, y, width, height;
rb_get_args(argc, argv, "iiii", &x, &y, &width, &height RB_ARG_END); rb_get_args(argc, argv, "iiii", &x, &y, &width, &height RB_ARG_END);
@ -87,27 +81,23 @@ DEF_PROP_OBJ_VAL(Viewport, Tone, Tone, "tone")
DEF_PROP_I(Viewport, OX) DEF_PROP_I(Viewport, OX)
DEF_PROP_I(Viewport, OY) DEF_PROP_I(Viewport, OY)
void viewportBindingInit() {
void
viewportBindingInit()
{
VALUE klass = rb_define_class("Viewport", rb_cObject); VALUE klass = rb_define_class("Viewport", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&ViewportType>); rb_define_alloc_func(klass, classAllocate<&ViewportType>);
#else #else
rb_define_alloc_func(klass, ViewportAllocate); rb_define_alloc_func(klass, ViewportAllocate);
#endif #endif
disposableBindingInit <Viewport>(klass); disposableBindingInit<Viewport>(klass);
flashableBindingInit <Viewport>(klass); flashableBindingInit<Viewport>(klass);
sceneElementBindingInit<Viewport>(klass); sceneElementBindingInit<Viewport>(klass);
_rb_define_method(klass, "initialize", viewportInitialize); _rb_define_method(klass, "initialize", viewportInitialize);
INIT_PROP_BIND( Viewport, Rect, "rect" ); INIT_PROP_BIND(Viewport, Rect, "rect");
INIT_PROP_BIND( Viewport, OX, "ox" ); INIT_PROP_BIND(Viewport, OX, "ox");
INIT_PROP_BIND( Viewport, OY, "oy" ); INIT_PROP_BIND(Viewport, OY, "oy");
INIT_PROP_BIND( Viewport, Color, "color" ); INIT_PROP_BIND(Viewport, Color, "color");
INIT_PROP_BIND( Viewport, Tone, "tone" ); INIT_PROP_BIND(Viewport, Tone, "tone");
} }

52
binding/window-binding.cpp
View file

@ -19,19 +19,18 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "window.h" #include "binding-util.h"
#include "disposable-binding.h" #include "disposable-binding.h"
#include "viewportelement-binding.h" #include "viewportelement-binding.h"
#include "binding-util.h" #include "window.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE(Window); DEF_TYPE(Window);
#else #else
DEF_ALLOCFUNC(Window); DEF_ALLOCFUNC(Window);
#endif #endif
RB_METHOD(windowInitialize) RB_METHOD(windowInitialize) {
{
Window *w = viewportElementInitialize<Window>(argc, argv, self); Window *w = viewportElementInitialize<Window>(argc, argv, self);
setPrivateData(self, w); setPrivateData(self, w);
@ -43,8 +42,7 @@ RB_METHOD(windowInitialize)
return self; return self;
} }
RB_METHOD(windowUpdate) RB_METHOD(windowUpdate) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Window *w = getPrivateData<Window>(self); Window *w = getPrivateData<Window>(self);
@ -72,37 +70,33 @@ DEF_PROP_I(Window, Opacity)
DEF_PROP_I(Window, BackOpacity) DEF_PROP_I(Window, BackOpacity)
DEF_PROP_I(Window, ContentsOpacity) DEF_PROP_I(Window, ContentsOpacity)
void windowBindingInit() {
void
windowBindingInit()
{
VALUE klass = rb_define_class("Window", rb_cObject); VALUE klass = rb_define_class("Window", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&WindowType>); rb_define_alloc_func(klass, classAllocate<&WindowType>);
#else #else
rb_define_alloc_func(klass, WindowAllocate); rb_define_alloc_func(klass, WindowAllocate);
#endif #endif
disposableBindingInit<Window>(klass);
disposableBindingInit <Window>(klass);
viewportElementBindingInit<Window>(klass); viewportElementBindingInit<Window>(klass);
_rb_define_method(klass, "initialize", windowInitialize); _rb_define_method(klass, "initialize", windowInitialize);
_rb_define_method(klass, "update", windowUpdate); _rb_define_method(klass, "update", windowUpdate);
INIT_PROP_BIND( Window, Windowskin, "windowskin" ); INIT_PROP_BIND(Window, Windowskin, "windowskin");
INIT_PROP_BIND( Window, Contents, "contents" ); INIT_PROP_BIND(Window, Contents, "contents");
INIT_PROP_BIND( Window, Stretch, "stretch" ); INIT_PROP_BIND(Window, Stretch, "stretch");
INIT_PROP_BIND( Window, CursorRect, "cursor_rect" ); INIT_PROP_BIND(Window, CursorRect, "cursor_rect");
INIT_PROP_BIND( Window, Active, "active" ); INIT_PROP_BIND(Window, Active, "active");
INIT_PROP_BIND( Window, Pause, "pause" ); INIT_PROP_BIND(Window, Pause, "pause");
INIT_PROP_BIND( Window, X, "x" ); INIT_PROP_BIND(Window, X, "x");
INIT_PROP_BIND( Window, Y, "y" ); INIT_PROP_BIND(Window, Y, "y");
INIT_PROP_BIND( Window, Width, "width" ); INIT_PROP_BIND(Window, Width, "width");
INIT_PROP_BIND( Window, Height, "height" ); INIT_PROP_BIND(Window, Height, "height");
INIT_PROP_BIND( Window, OX, "ox" ); INIT_PROP_BIND(Window, OX, "ox");
INIT_PROP_BIND( Window, OY, "oy" ); INIT_PROP_BIND(Window, OY, "oy");
INIT_PROP_BIND( Window, Opacity, "opacity" ); INIT_PROP_BIND(Window, Opacity, "opacity");
INIT_PROP_BIND( Window, BackOpacity, "back_opacity" ); INIT_PROP_BIND(Window, BackOpacity, "back_opacity");
INIT_PROP_BIND( Window, ContentsOpacity, "contents_opacity" ); INIT_PROP_BIND(Window, ContentsOpacity, "contents_opacity");
} }

77
binding/windowvx-binding.cpp
View file

@ -19,14 +19,14 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>. ** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "windowvx.h" #include "binding-util.h"
#include "disposable-binding.h" #include "disposable-binding.h"
#include "viewportelement-binding.h" #include "viewportelement-binding.h"
#include "binding-util.h" #include "windowvx.h"
#include "bitmap.h" #include "bitmap.h"
#ifndef OLD_RUBY #if RAPI_FULL > 187
DEF_TYPE_CUSTOMNAME(WindowVX, "Window"); DEF_TYPE_CUSTOMNAME(WindowVX, "Window");
#else #else
DEF_ALLOCFUNC(WindowVX); DEF_ALLOCFUNC(WindowVX);
@ -34,12 +34,10 @@ DEF_ALLOCFUNC(WindowVX);
void bitmapInitProps(Bitmap *b, VALUE self); void bitmapInitProps(Bitmap *b, VALUE self);
RB_METHOD(windowVXInitialize) RB_METHOD(windowVXInitialize) {
{
WindowVX *w; WindowVX *w;
if (rgssVer >= 3) if (rgssVer >= 3) {
{
int x, y, width, height; int x, y, width, height;
x = y = width = height = 0; x = y = width = height = 0;
@ -47,9 +45,7 @@ RB_METHOD(windowVXInitialize)
rb_get_args(argc, argv, "iiii", &x, &y, &width, &height RB_ARG_END); rb_get_args(argc, argv, "iiii", &x, &y, &width, &height RB_ARG_END);
w = new WindowVX(x, y, width, height); w = new WindowVX(x, y, width, height);
} } else {
else
{
w = viewportElementInitialize<WindowVX>(argc, argv, self); w = viewportElementInitialize<WindowVX>(argc, argv, self);
} }
@ -70,8 +66,7 @@ RB_METHOD(windowVXInitialize)
return self; return self;
} }
RB_METHOD(windowVXUpdate) RB_METHOD(windowVXUpdate) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
WindowVX *w = getPrivateData<WindowVX>(self); WindowVX *w = getPrivateData<WindowVX>(self);
@ -81,8 +76,7 @@ RB_METHOD(windowVXUpdate)
return Qnil; return Qnil;
} }
RB_METHOD(windowVXMove) RB_METHOD(windowVXMove) {
{
WindowVX *w = getPrivateData<WindowVX>(self); WindowVX *w = getPrivateData<WindowVX>(self);
int x, y, width, height; int x, y, width, height;
@ -93,8 +87,7 @@ RB_METHOD(windowVXMove)
return Qnil; return Qnil;
} }
RB_METHOD(windowVXIsOpen) RB_METHOD(windowVXIsOpen) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
WindowVX *w = getPrivateData<WindowVX>(self); WindowVX *w = getPrivateData<WindowVX>(self);
@ -102,8 +95,7 @@ RB_METHOD(windowVXIsOpen)
return rb_bool_new(w->isOpen()); return rb_bool_new(w->isOpen());
} }
RB_METHOD(windowVXIsClosed) RB_METHOD(windowVXIsClosed) {
{
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
WindowVX *w = getPrivateData<WindowVX>(self); WindowVX *w = getPrivateData<WindowVX>(self);
@ -134,47 +126,44 @@ DEF_PROP_B(WindowVX, Active)
DEF_PROP_B(WindowVX, ArrowsVisible) DEF_PROP_B(WindowVX, ArrowsVisible)
DEF_PROP_B(WindowVX, Pause) DEF_PROP_B(WindowVX, Pause)
void void windowVXBindingInit() {
windowVXBindingInit()
{
VALUE klass = rb_define_class("Window", rb_cObject); VALUE klass = rb_define_class("Window", rb_cObject);
#ifndef OLD_RUBY #if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&WindowVXType>); rb_define_alloc_func(klass, classAllocate<&WindowVXType>);
#else #else
rb_define_alloc_func(klass, WindowVXAllocate); rb_define_alloc_func(klass, WindowVXAllocate);
#endif #endif
disposableBindingInit <WindowVX>(klass); disposableBindingInit<WindowVX>(klass);
viewportElementBindingInit<WindowVX>(klass); viewportElementBindingInit<WindowVX>(klass);
_rb_define_method(klass, "initialize", windowVXInitialize); _rb_define_method(klass, "initialize", windowVXInitialize);
_rb_define_method(klass, "update", windowVXUpdate); _rb_define_method(klass, "update", windowVXUpdate);
INIT_PROP_BIND( WindowVX, Windowskin, "windowskin" ); INIT_PROP_BIND(WindowVX, Windowskin, "windowskin");
INIT_PROP_BIND( WindowVX, Contents, "contents" ); INIT_PROP_BIND(WindowVX, Contents, "contents");
INIT_PROP_BIND( WindowVX, CursorRect, "cursor_rect" ); INIT_PROP_BIND(WindowVX, CursorRect, "cursor_rect");
INIT_PROP_BIND( WindowVX, Active, "active" ); INIT_PROP_BIND(WindowVX, Active, "active");
INIT_PROP_BIND( WindowVX, Pause, "pause" ); INIT_PROP_BIND(WindowVX, Pause, "pause");
INIT_PROP_BIND( WindowVX, X, "x" ); INIT_PROP_BIND(WindowVX, X, "x");
INIT_PROP_BIND( WindowVX, Y, "y" ); INIT_PROP_BIND(WindowVX, Y, "y");
INIT_PROP_BIND( WindowVX, Width, "width" ); INIT_PROP_BIND(WindowVX, Width, "width");
INIT_PROP_BIND( WindowVX, Height, "height" ); INIT_PROP_BIND(WindowVX, Height, "height");
INIT_PROP_BIND( WindowVX, OX, "ox" ); INIT_PROP_BIND(WindowVX, OX, "ox");
INIT_PROP_BIND( WindowVX, OY, "oy" ); INIT_PROP_BIND(WindowVX, OY, "oy");
INIT_PROP_BIND( WindowVX, Opacity, "opacity" ); INIT_PROP_BIND(WindowVX, Opacity, "opacity");
INIT_PROP_BIND( WindowVX, BackOpacity, "back_opacity" ); INIT_PROP_BIND(WindowVX, BackOpacity, "back_opacity");
INIT_PROP_BIND( WindowVX, ContentsOpacity, "contents_opacity" ); INIT_PROP_BIND(WindowVX, ContentsOpacity, "contents_opacity");
INIT_PROP_BIND( WindowVX, Openness, "openness" ); INIT_PROP_BIND(WindowVX, Openness, "openness");
if (rgssVer >= 3) if (rgssVer >= 3) {
{
_rb_define_method(klass, "move", windowVXMove); _rb_define_method(klass, "move", windowVXMove);
_rb_define_method(klass, "open?", windowVXIsOpen); _rb_define_method(klass, "open?", windowVXIsOpen);
_rb_define_method(klass, "close?", windowVXIsClosed); _rb_define_method(klass, "close?", windowVXIsClosed);
INIT_PROP_BIND( WindowVX, ArrowsVisible, "arrows_visible" ); INIT_PROP_BIND(WindowVX, ArrowsVisible, "arrows_visible");
INIT_PROP_BIND( WindowVX, Padding, "padding" ); INIT_PROP_BIND(WindowVX, Padding, "padding");
INIT_PROP_BIND( WindowVX, PaddingBottom, "padding_bottom" ); INIT_PROP_BIND(WindowVX, PaddingBottom, "padding_bottom");
INIT_PROP_BIND( WindowVX, Tone, "tone" ); INIT_PROP_BIND(WindowVX, Tone, "tone");
} }
} }