mirrors/mkxp-z
1
0
Fork 0
mirror of https://github.com/mkxp-z/mkxp-z.git synced 2025-04-21 21:52:04 +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:
Roza 2020-02-26 12:44:37 -05:00
parent 41e604b992
commit 1434e9e313
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" {
#include <ruby.h>
#ifndef OLD_RUBY
#if RAPI_FULL >= 190
#include <ruby/encoding.h>
#endif
}
@ -369,7 +369,7 @@ RB_METHOD(mriRgssMain) {
while (true) {
VALUE exc = Qnil;
#if RUBYCOMPAT < 270
#if RAPI_FULL < 270
rb_rescue2((VALUE(*)(ANYARGS))rgssMainCb, rb_block_proc(),
(VALUE(*)(ANYARGS))rgssMainRescue, (VALUE)&exc, rb_eException,
(VALUE)0);
@ -431,7 +431,7 @@ RB_METHOD(_kernelCaller) {
return trace;
}
#ifndef OLD_RUBY
#if RAPI_FULL > 187
static VALUE newStringUTF8(const char *string, long length) {
return rb_enc_str_new(string, length, rb_utf8_encoding());
}
@ -571,7 +571,7 @@ static void runRMXPScripts(BacktraceData &btData) {
#endif
while (true) {
#if defined(OLD_RUBY) && defined(NO_CONSOLE)
#if RAPI_FULL < 200 && defined(NO_CONSOLE)
VALUE iostr = rb_str_new2(NULL_IO);
// Sysinit isn't a thing yet, so send io to /dev/null instead
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() {
#ifndef OLD_RUBY
#if RAPI_FULL > 200
/* Normally only a ruby executable would do a sysinit,
* but not doing it will lead to crashes due to closed
* stdio streams on some platforms (eg. Windows) */
@ -750,7 +750,7 @@ static void mriBindingExecute() {
runRMXPScripts(btData);
#endif
#ifndef OLD_RUBY
#if RAPI_FULL > 187
VALUE exc = rb_errinfo();
#else
VALUE exc = rb_gv_get("$!");

4
binding/binding-types.h
View file

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

400
binding/binding-util.cpp
View file

@ -21,305 +21,275 @@
#include "binding-util.h"
#include "sharedstate.h"
#include "exception.h"
#include "sharedstate.h"
#include "src/util.h"
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
RbData *getRbData()
{
return static_cast<RbData*>(shState->bindingData());
RbData *getRbData() { return static_cast<RbData *>(shState->bindingData()); }
struct {
RbException id;
const char *name;
} static customExc[] = {
{MKXP, "MKXPError"}, {PHYSFS, "PHYSFSError"}, {SDL, "SDLError"}};
RbData::RbData() {
for (size_t i = 0; i < ARRAY_SIZE(customExc); ++i)
exc[customExc[i].id] = rb_define_class(customExc[i].name, rb_eException);
exc[RGSS] = rb_define_class("RGSSError", rb_eStandardError);
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[IOError] = rb_eIOError;
exc[TypeError] = rb_eTypeError;
exc[ArgumentError] = rb_eArgError;
}
struct
{
RbException id;
const char *name;
} static customExc[] =
{
{ MKXP, "MKXPError" },
{ PHYSFS, "PHYSFSError" },
{ SDL, "SDLError" }
};
RbData::RbData()
{
for (size_t i = 0; i < ARRAY_SIZE(customExc); ++i)
exc[customExc[i].id] = rb_define_class(customExc[i].name, rb_eException);
exc[RGSS] = rb_define_class("RGSSError", rb_eStandardError);
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[IOError] = rb_eIOError;
exc[TypeError] = rb_eTypeError;
exc[ArgumentError] = rb_eArgError;
}
RbData::~RbData()
{
}
RbData::~RbData() {}
/* Indexed with Exception::Type */
static const RbException excToRbExc[] =
{
static const RbException excToRbExc[] = {
RGSS, /* RGSSError */
ErrnoENOENT, /* NoFileError */
IOError,
TypeError,
ArgumentError,
TypeError, ArgumentError,
PHYSFS, /* PHYSFSError */
SDL, /* SDLError */
MKXP /* MKXPError */
PHYSFS, /* PHYSFSError */
SDL, /* SDLError */
MKXP /* MKXPError */
};
void raiseRbExc(const Exception &exc)
{
RbData *data = getRbData();
VALUE excClass = data->exc[excToRbExc[exc.type]];
void raiseRbExc(const Exception &exc) {
RbData *data = getRbData();
VALUE excClass = data->exc[excToRbExc[exc.type]];
rb_raise(excClass, "%s", exc.msg.c_str());
rb_raise(excClass, "%s", exc.msg.c_str());
}
void
raiseDisposedAccess(VALUE self)
{
#ifndef OLD_RUBY
const char *klassName = RTYPEDDATA_TYPE(self)->wrap_struct_name;
void raiseDisposedAccess(VALUE self) {
#if RAPI_FULL > 187
const char *klassName = RTYPEDDATA_TYPE(self)->wrap_struct_name;
#else
const char *klassName = rb_obj_classname(self);
const char *klassName = rb_obj_classname(self);
#endif
char buf[32];
char buf[32];
strncpy(buf, klassName, sizeof(buf));
buf[0] = tolower(buf[0]);
strncpy(buf, klassName, sizeof(buf));
buf[0] = tolower(buf[0]);
rb_raise(getRbData()->exc[RGSS], "disposed %s", buf);
rb_raise(getRbData()->exc[RGSS], "disposed %s", buf);
}
int
rb_get_args(int argc, VALUE *argv, const char *format, ...)
{
char c;
VALUE *arg = argv;
va_list ap;
bool opt = false;
int argI = 0;
int rb_get_args(int argc, VALUE *argv, const char *format, ...) {
char c;
VALUE *arg = argv;
va_list ap;
bool opt = false;
int argI = 0;
va_start(ap, format);
va_start(ap, format);
while ((c = *format++))
{
switch (c)
{
case '|' :
break;
default:
// FIXME print num of needed args vs provided
if (argc <= argI && !opt)
rb_raise(rb_eArgError, "wrong number of arguments");
while ((c = *format++)) {
switch (c) {
case '|':
break;
default:
// FIXME print num of needed args vs provided
if (argc <= argI && !opt)
rb_raise(rb_eArgError, "wrong number of arguments");
break;
}
break;
}
if (argI >= argc)
break;
if (argI >= argc)
break;
switch (c)
{
case 'o' :
{
if (argI >= argc)
break;
switch (c) {
case 'o': {
if (argI >= argc)
break;
VALUE *obj = va_arg(ap, VALUE*);
VALUE *obj = va_arg(ap, VALUE *);
*obj = *arg++;
++argI;
*obj = *arg++;
++argI;
break;
}
break;
}
case 'S' :
{
if (argI >= argc)
break;
case 'S': {
if (argI >= argc)
break;
VALUE *str = va_arg(ap, VALUE*);
VALUE tmp = *arg;
VALUE *str = va_arg(ap, VALUE *);
VALUE tmp = *arg;
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
*str = tmp;
++argI;
*str = tmp;
++argI;
break;
}
break;
}
case 's' :
{
if (argI >= argc)
break;
case 's': {
if (argI >= argc)
break;
const char **s = va_arg(ap, const char**);
int *len = va_arg(ap, int*);
const char **s = va_arg(ap, const char **);
int *len = va_arg(ap, int *);
VALUE tmp = *arg;
VALUE tmp = *arg;
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
*s = RSTRING_PTR(tmp);
*len = RSTRING_LEN(tmp);
++argI;
*s = RSTRING_PTR(tmp);
*len = RSTRING_LEN(tmp);
++argI;
break;
}
break;
}
case 'z' :
{
if (argI >= argc)
break;
case 'z': {
if (argI >= argc)
break;
const char **s = va_arg(ap, const char**);
const char **s = va_arg(ap, const char **);
VALUE tmp = *arg++;
VALUE tmp = *arg++;
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
if (!RB_TYPE_P(tmp, RUBY_T_STRING))
rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
*s = RSTRING_PTR(tmp);
++argI;
*s = RSTRING_PTR(tmp);
++argI;
break;
}
break;
}
case 'f' :
{
if (argI >= argc)
break;
case 'f': {
if (argI >= argc)
break;
double *f = va_arg(ap, double*);
VALUE fVal = *arg++;
double *f = va_arg(ap, double *);
VALUE fVal = *arg++;
rb_float_arg(fVal, f, argI);
rb_float_arg(fVal, f, argI);
++argI;
break;
}
++argI;
break;
}
case 'i' :
{
if (argI >= argc)
break;
case 'i': {
if (argI >= argc)
break;
int *i = va_arg(ap, int*);
VALUE iVal = *arg++;
int *i = va_arg(ap, int *);
VALUE iVal = *arg++;
rb_int_arg(iVal, i, argI);
rb_int_arg(iVal, i, argI);
++argI;
break;
}
++argI;
break;
}
case 'b' :
{
if (argI >= argc)
break;
case 'b': {
if (argI >= argc)
break;
bool *b = va_arg(ap, bool*);
VALUE bVal = *arg++;
bool *b = va_arg(ap, bool *);
VALUE bVal = *arg++;
rb_bool_arg(bVal, b, argI);
rb_bool_arg(bVal, b, argI);
++argI;
break;
}
++argI;
break;
}
case 'n' :
{
if (argI >= argc)
break;
case 'n': {
if (argI >= argc)
break;
ID *sym = va_arg(ap, ID*);
ID *sym = va_arg(ap, ID *);
VALUE symVal = *arg++;
VALUE symVal = *arg++;
if (!SYMBOL_P(symVal))
rb_raise(rb_eTypeError, "Argument %d: Expected symbol", argI);
if (!SYMBOL_P(symVal))
rb_raise(rb_eTypeError, "Argument %d: Expected symbol", argI);
*sym = SYM2ID(symVal);
++argI;
*sym = SYM2ID(symVal);
++argI;
break;
}
break;
}
case '|' :
opt = true;
break;
case '|':
opt = true;
break;
default:
rb_raise(rb_eFatal, "invalid argument specifier %c", c);
}
}
default:
rb_raise(rb_eFatal, "invalid argument specifier %c", c);
}
}
#ifndef NDEBUG
/* Pop remaining arg pointers off
* the stack to check for RB_ARG_END */
format--;
/* Pop remaining arg pointers off
* the stack to check for RB_ARG_END */
format--;
while ((c = *format++))
{
switch (c)
{
case 'o' :
case 'S' :
va_arg(ap, VALUE*);
break;
while ((c = *format++)) {
switch (c) {
case 'o':
case 'S':
va_arg(ap, VALUE *);
break;
case 's' :
va_arg(ap, const char**);
va_arg(ap, int*);
break;
case 's':
va_arg(ap, const char **);
va_arg(ap, int *);
break;
case 'z' :
va_arg(ap, const char**);
break;
case 'z':
va_arg(ap, const char **);
break;
case 'f' :
va_arg(ap, double*);
break;
case 'f':
va_arg(ap, double *);
break;
case 'i' :
va_arg(ap, int*);
break;
case 'i':
va_arg(ap, int *);
break;
case 'b' :
va_arg(ap, bool*);
break;
}
}
case 'b':
va_arg(ap, bool *);
break;
}
}
// FIXME print num of needed args vs provided
if (!c && argc > argI)
rb_raise(rb_eArgError, "wrong number of arguments");
// FIXME print num of needed args vs provided
if (!c && argc > argI)
rb_raise(rb_eArgError, "wrong number of arguments");
/* Verify correct termination */
void *argEnd = va_arg(ap, void*);
(void) argEnd;
assert(argEnd == RB_ARG_END_VAL);
/* Verify correct termination */
void *argEnd = va_arg(ap, void *);
(void)argEnd;
assert(argEnd == RB_ARG_END_VAL);
#endif
va_end(ap);
va_end(ap);
return argI;
return argI;
}

54
binding/binding-util.h
View file

@ -23,9 +23,25 @@
#define BINDING_UTIL_H
#include <ruby.h>
#ifndef LEGACY_RUBY
#include <ruby/version.h>
#else
#include <version.h>
#endif
#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 {
RGSS = 0,
Reset,
@ -59,12 +75,11 @@ struct Exception;
void raiseRbExc(const Exception &exc);
#ifndef OLD_RUBY
#if RAPI_FULL > 187
#define DECL_TYPE(Klass) extern rb_data_type_t Klass##Type
/* 2.1 has added a new field (flags) to rb_data_type_t */
#include <ruby/version.h>
#if RUBY_API_VERSION_MAJOR >= 2 && RUBY_API_VERSION_MINOR >= 1
#if RAPI_FULL >= 210
/* TODO: can mkxp use RUBY_TYPED_FREE_IMMEDIATELY here? */
#define DEF_TYPE_FLAGS 0
#else
@ -72,15 +87,14 @@ void raiseRbExc(const Exception &exc);
#endif
#endif
#ifndef OLD_RUBY
#if RUBYCOMPAT < 270
#if RAPI_MAJOR > 1
#if RAPI_FULL < 270
#define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free) \
rb_data_type_t Klass##Type = { \
Name, {0, Free, 0, {0, 0}}, 0, 0, DEF_TYPE_FLAGS}
#else
#define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free) \
rb_data_type_t Klass##Type = { \
Name, {0, Free, 0, 0, 0}, 0, 0, DEF_TYPE_FLAGS}
rb_data_type_t Klass##Type = {Name, {0, Free, 0, 0, 0}, 0, 0, DEF_TYPE_FLAGS}
#endif
#define DEF_TYPE_CUSTOMFREE(Klass, Free) \
@ -93,7 +107,7 @@ void raiseRbExc(const Exception &exc);
#endif
// Ruby 1.8 helper stuff
#ifdef OLD_RUBY
#if RAPI_FULL <= 187
#define RUBY_T_FIXNUM T_FIXNUM
#define RUBY_T_TRUE T_TRUE
@ -144,10 +158,10 @@ void raiseRbExc(const Exception &exc);
#endif
// end
#ifndef OLD_RUBY
#if RAPI_FULL > 187
template <rb_data_type_t *rbType> static VALUE classAllocate(VALUE klass) {
/* 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);
#else
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);
template <class C> inline C *getPrivateData(VALUE self) {
#ifndef OLD_RUBY
#if RAPI_FULL > 187
C *c = static_cast<C *>(RTYPEDDATA_DATA(self));
#else
C *c = static_cast<C *>(DATA_PTR(self));
@ -172,13 +186,13 @@ template <class C> inline C *getPrivateData(VALUE self) {
template <class C>
static inline C *
#ifndef OLD_RUBY
#if RAPI_FULL > 187
getPrivateDataCheck(VALUE self, const rb_data_type_t &type)
#else
getPrivateDataCheck(VALUE self, const char *type)
#endif
{
#ifdef OLD_RUBY
#if RAPI_FULL <= 187
rb_check_type(self, T_DATA);
VALUE otherObj = rb_const_get(rb_cObject, rb_intern(type));
#else
@ -197,7 +211,7 @@ getPrivateDataCheck(VALUE self, const char *type)
}
static inline void setPrivateData(VALUE self, void *p) {
#ifndef OLD_RUBY
#if RAPI_FULL > 187
RTYPEDDATA_DATA(self) = p;
#else
DATA_PTR(self) = p;
@ -205,13 +219,13 @@ static inline void setPrivateData(VALUE self, void *p) {
}
inline VALUE
#ifndef OLD_RUBY
#if RAPI_FULL > 187
wrapObject(void *p, const rb_data_type_t &type, VALUE underKlass = rb_cObject)
#else
wrapObject(void *p, const char *type, VALUE underKlass = rb_cObject)
#endif
{
#ifndef OLD_RUBY
#if RAPI_FULL > 187
VALUE klass = rb_const_get(underKlass, rb_intern(type.wrap_struct_name));
#else
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,
#ifndef OLD_RUBY
#if RAPI_FULL > 187
const rb_data_type_t &type,
#else
const char *type,
@ -346,7 +360,7 @@ inline void rb_check_argc(int actual, int expected) {
expected);
}
#ifdef OLD_RUBY
#if RAPI_FULL <= 187
static inline void rb_error_arity(int argc, int min, int max) {
if (argc > max || argc < min)
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,
* because self.disposed? is not checked in this case.
* Should make this more clear */
#ifndef OLD_RUBY
#if RAPI_FULL > 187
#define DEF_PROP_OBJ_REF(Klass, PropKlass, PropName, prop_iv) \
RB_METHOD(Klass##Get##PropName) { \
RB_UNUSED_PARAM; \
@ -438,7 +452,7 @@ static inline VALUE rb_file_open_str(VALUE filename, const char *mode) {
#endif
/* 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) \
RB_METHOD(Klass##Get##PropName) { \
RB_UNUSED_PARAM; \

656
binding/bitmap-binding.cpp
View file

@ -19,508 +19,466 @@
** 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-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);
#else
DEF_ALLOCFUNC(Bitmap);
#endif
static const char *objAsStringPtr(VALUE obj)
{
VALUE str = rb_obj_as_string(obj);
return RSTRING_PTR(str);
static const char *objAsStringPtr(VALUE obj) {
VALUE str = rb_obj_as_string(obj);
return RSTRING_PTR(str);
}
void bitmapInitProps(Bitmap *b, VALUE self)
{
/* Wrap properties */
VALUE fontKlass = rb_const_get(rb_cObject, rb_intern("Font"));
VALUE fontObj = rb_obj_alloc(fontKlass);
rb_obj_call_init(fontObj, 0, 0);
void bitmapInitProps(Bitmap *b, VALUE self) {
/* Wrap properties */
VALUE fontKlass = rb_const_get(rb_cObject, rb_intern("Font"));
VALUE fontObj = rb_obj_alloc(fontKlass);
rb_obj_call_init(fontObj, 0, 0);
Font *font = getPrivateData<Font>(fontObj);
b->setInitFont(font);
Font *font = getPrivateData<Font>(fontObj);
b->setInitFont(font);
rb_iv_set(self, "font", fontObj);
rb_iv_set(self, "font", fontObj);
}
RB_METHOD(bitmapInitialize)
{
Bitmap *b = 0;
RB_METHOD(bitmapInitialize) {
Bitmap *b = 0;
if (argc == 1)
{
char *filename;
rb_get_args(argc, argv, "z", &filename RB_ARG_END);
if (argc == 1) {
char *filename;
rb_get_args(argc, argv, "z", &filename RB_ARG_END);
GUARD_EXC( b = new Bitmap(filename); )
}
else
{
int width, height;
rb_get_args(argc, argv, "ii", &width, &height RB_ARG_END);
GUARD_EXC(b = new Bitmap(filename);)
} else {
int width, height;
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);
bitmapInitProps(b, self);
setPrivateData(self, b);
bitmapInitProps(b, self);
return self;
return self;
}
RB_METHOD(bitmapWidth)
{
RB_UNUSED_PARAM;
RB_METHOD(bitmapWidth) {
RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self);
Bitmap *b = getPrivateData<Bitmap>(self);
int value = 0;
GUARD_EXC( value = b->width(); );
int value = 0;
GUARD_EXC(value = b->width(););
return INT2FIX(value);
return INT2FIX(value);
}
RB_METHOD(bitmapHeight)
{
RB_UNUSED_PARAM;
RB_METHOD(bitmapHeight) {
RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self);
Bitmap *b = getPrivateData<Bitmap>(self);
int value = 0;
GUARD_EXC( value = b->height(); );
int value = 0;
GUARD_EXC(value = b->height(););
return INT2FIX(value);
return INT2FIX(value);
}
RB_METHOD(bitmapRect)
{
RB_UNUSED_PARAM;
RB_METHOD(bitmapRect) {
RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self);
Bitmap *b = getPrivateData<Bitmap>(self);
IntRect rect;
GUARD_EXC( rect = b->rect(); );
IntRect 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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapBlt) {
Bitmap *b = getPrivateData<Bitmap>(self);
int x, y;
VALUE srcObj;
VALUE srcRectObj;
int opacity = 255;
int x, y;
VALUE srcObj;
VALUE srcRectObj;
int opacity = 255;
Bitmap *src;
Rect *srcRect;
Bitmap *src;
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);
srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType);
src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType);
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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapStretchBlt) {
Bitmap *b = getPrivateData<Bitmap>(self);
VALUE destRectObj;
VALUE srcObj;
VALUE srcRectObj;
int opacity = 255;
VALUE destRectObj;
VALUE srcObj;
VALUE srcRectObj;
int opacity = 255;
Bitmap *src;
Rect *destRect, *srcRect;
Bitmap *src;
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);
destRect = getPrivateDataCheck<Rect>(destRectObj, RectType);
srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType);
src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType);
destRect = getPrivateDataCheck<Rect>(destRectObj, 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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapFillRect) {
Bitmap *b = getPrivateData<Bitmap>(self);
VALUE colorObj;
Color *color;
VALUE colorObj;
Color *color;
if (argc == 2)
{
VALUE rectObj;
Rect *rect;
if (argc == 2) {
VALUE rectObj;
Rect *rect;
rb_get_args(argc, argv, "oo", &rectObj, &colorObj RB_ARG_END);
rb_get_args(argc, argv, "oo", &rectObj, &colorObj RB_ARG_END);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
color = getPrivateDataCheck<Color>(colorObj, ColorType);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
color = getPrivateDataCheck<Color>(colorObj, ColorType);
GUARD_EXC( b->fillRect(rect->toIntRect(), color->norm); );
}
else
{
int x, y, width, height;
GUARD_EXC(b->fillRect(rect->toIntRect(), color->norm););
} else {
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_UNUSED_PARAM;
RB_METHOD(bitmapClear) {
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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapGetPixel) {
Bitmap *b = getPrivateData<Bitmap>(self);
int x, y;
int x, y;
rb_get_args(argc, argv, "ii", &x, &y RB_ARG_END);
rb_get_args(argc, argv, "ii", &x, &y RB_ARG_END);
Color value;
GUARD_EXC( value = b->getPixel(x, y); );
Color value;
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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapSetPixel) {
Bitmap *b = getPrivateData<Bitmap>(self);
int x, y;
VALUE colorObj;
int x, y;
VALUE colorObj;
Color *color;
Color *color;
rb_get_args(argc, argv, "iio", &x, &y, &colorObj RB_ARG_END);
rb_get_args(argc, argv, "iio", &x, &y, &colorObj RB_ARG_END);
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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapHueChange) {
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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapDrawText) {
Bitmap *b = getPrivateData<Bitmap>(self);
const char *str;
int align = Bitmap::Left;
const char *str;
int align = Bitmap::Left;
if (argc == 2 || argc == 3)
{
VALUE rectObj;
Rect *rect;
if (argc == 2 || argc == 3) {
VALUE rectObj;
Rect *rect;
if (rgssVer >= 2)
{
VALUE strObj;
rb_get_args(argc, argv, "oo|i", &rectObj, &strObj, &align RB_ARG_END);
if (rgssVer >= 2) {
VALUE strObj;
rb_get_args(argc, argv, "oo|i", &rectObj, &strObj, &align RB_ARG_END);
str = objAsStringPtr(strObj);
}
else
{
rb_get_args(argc, argv, "oz|i", &rectObj, &str, &align RB_ARG_END);
}
str = objAsStringPtr(strObj);
} else {
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); );
}
else
{
int x, y, width, height;
GUARD_EXC(b->drawText(rect->toIntRect(), str, align););
} else {
int x, y, width, height;
if (rgssVer >= 2)
{
VALUE strObj;
rb_get_args(argc, argv, "iiiio|i", &x, &y, &width, &height, &strObj, &align RB_ARG_END);
if (rgssVer >= 2) {
VALUE strObj;
rb_get_args(argc, argv, "iiiio|i", &x, &y, &width, &height, &strObj,
&align RB_ARG_END);
str = objAsStringPtr(strObj);
}
else
{
rb_get_args(argc, argv, "iiiiz|i", &x, &y, &width, &height, &str, &align RB_ARG_END);
}
str = objAsStringPtr(strObj);
} else {
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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapTextSize) {
Bitmap *b = getPrivateData<Bitmap>(self);
const char *str;
const char *str;
if (rgssVer >= 2)
{
VALUE strObj;
rb_get_args(argc, argv, "o", &strObj RB_ARG_END);
if (rgssVer >= 2) {
VALUE strObj;
rb_get_args(argc, argv, "o", &strObj RB_ARG_END);
str = objAsStringPtr(strObj);
}
else
{
rb_get_args(argc, argv, "z", &str RB_ARG_END);
}
str = objAsStringPtr(strObj);
} else {
rb_get_args(argc, argv, "z", &str RB_ARG_END);
}
IntRect value;
GUARD_EXC( value = b->textSize(str); );
IntRect value;
GUARD_EXC(value = b->textSize(str););
Rect *rect = new Rect(value);
Rect *rect = new Rect(value);
return wrapObject(rect, RectType);
return wrapObject(rect, RectType);
}
DEF_PROP_OBJ_VAL(Bitmap, Font, Font, "font")
RB_METHOD(bitmapGradientFillRect)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapGradientFillRect) {
Bitmap *b = getPrivateData<Bitmap>(self);
VALUE color1Obj, color2Obj;
Color *color1, *color2;
bool vertical = false;
VALUE color1Obj, color2Obj;
Color *color1, *color2;
bool vertical = false;
if (argc == 3 || argc == 4)
{
VALUE rectObj;
Rect *rect;
if (argc == 3 || argc == 4) {
VALUE rectObj;
Rect *rect;
rb_get_args(argc, argv, "ooo|b", &rectObj,
&color1Obj, &color2Obj, &vertical RB_ARG_END);
rb_get_args(argc, argv, "ooo|b", &rectObj, &color1Obj, &color2Obj,
&vertical RB_ARG_END);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
color1 = getPrivateDataCheck<Color>(color1Obj, ColorType);
color2 = getPrivateDataCheck<Color>(color2Obj, ColorType);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
color1 = getPrivateDataCheck<Color>(color1Obj, ColorType);
color2 = getPrivateDataCheck<Color>(color2Obj, ColorType);
GUARD_EXC( b->gradientFillRect(rect->toIntRect(), color1->norm, color2->norm, vertical); );
}
else
{
int x, y, width, height;
GUARD_EXC(b->gradientFillRect(rect->toIntRect(), color1->norm, color2->norm,
vertical););
} else {
int x, y, width, height;
rb_get_args(argc, argv, "iiiioo|b", &x, &y, &width, &height,
&color1Obj, &color2Obj, &vertical RB_ARG_END);
rb_get_args(argc, argv, "iiiioo|b", &x, &y, &width, &height, &color1Obj,
&color2Obj, &vertical RB_ARG_END);
color1 = getPrivateDataCheck<Color>(color1Obj, ColorType);
color2 = getPrivateDataCheck<Color>(color2Obj, ColorType);
color1 = getPrivateDataCheck<Color>(color1Obj, 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)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapClearRect) {
Bitmap *b = getPrivateData<Bitmap>(self);
if (argc == 1)
{
VALUE rectObj;
Rect *rect;
if (argc == 1) {
VALUE rectObj;
Rect *rect;
rb_get_args(argc, argv, "o", &rectObj RB_ARG_END);
rb_get_args(argc, argv, "o", &rectObj RB_ARG_END);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
GUARD_EXC( b->clearRect(rect->toIntRect()); );
}
else
{
int x, y, width, height;
GUARD_EXC(b->clearRect(rect->toIntRect()););
} else {
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_UNUSED_PARAM;
RB_METHOD(bitmapBlur) {
RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self);
Bitmap *b = getPrivateData<Bitmap>(self);
b->blur();
b->blur();
return Qnil;
return Qnil;
}
RB_METHOD(bitmapRadialBlur)
{
Bitmap *b = getPrivateData<Bitmap>(self);
RB_METHOD(bitmapRadialBlur) {
Bitmap *b = getPrivateData<Bitmap>(self);
int angle, divisions;
rb_get_args(argc, argv, "ii", &angle, &divisions RB_ARG_END);
int angle, divisions;
rb_get_args(argc, argv, "ii", &angle, &divisions RB_ARG_END);
b->radialBlur(angle, divisions);
b->radialBlur(angle, divisions);
return Qnil;
return Qnil;
}
RB_METHOD(bitmapGetRawData)
{
RB_UNUSED_PARAM;
Bitmap *b = getPrivateData<Bitmap>(self);
int size = b->width()*b->height()*4;
VALUE ret = rb_str_new(0, size);
RB_METHOD(bitmapGetRawData) {
RB_UNUSED_PARAM;
GUARD_EXC ( b->getRaw(RSTRING_PTR(ret), size); );
return ret;
Bitmap *b = getPrivateData<Bitmap>(self);
int size = b->width() * b->height() * 4;
VALUE ret = rb_str_new(0, size);
GUARD_EXC(b->getRaw(RSTRING_PTR(ret), size););
return ret;
}
RB_METHOD(bitmapSetRawData)
{
RB_UNUSED_PARAM;
RB_METHOD(bitmapSetRawData) {
RB_UNUSED_PARAM;
VALUE str;
rb_scan_args(argc, argv, "1", &str);
SafeStringValue(str);
Bitmap *b = getPrivateData<Bitmap>(self);
GUARD_EXC( b->replaceRaw(RSTRING_PTR(str), RSTRING_LEN(str)); );
VALUE str;
rb_scan_args(argc, argv, "1", &str);
SafeStringValue(str);
Bitmap *b = getPrivateData<Bitmap>(self);
GUARD_EXC(b->replaceRaw(RSTRING_PTR(str), RSTRING_LEN(str)););
return self;
}
RB_METHOD(bitmapSaveToFile) {
RB_UNUSED_PARAM;
VALUE str;
rb_scan_args(argc, argv, "1", &str);
SafeStringValue(str);
Bitmap *b = getPrivateData<Bitmap>(self);
try {
b->saveToFile(RSTRING_PTR(str));
} catch (const Exception &e) {
raiseRbExc(e);
}
return RUBY_Qnil;
}
RB_METHOD(bitmapInitializeCopy) {
rb_check_argc(argc, 1);
VALUE origObj = argv[0];
if (!OBJ_INIT_COPY(self, origObj))
return self;
Bitmap *orig = getPrivateData<Bitmap>(origObj);
Bitmap *b = 0;
GUARD_EXC(b = new Bitmap(*orig););
bitmapInitProps(b, self);
b->setFont(orig->getFont());
setPrivateData(self, b);
return self;
}
RB_METHOD(bitmapSaveToFile)
{
RB_UNUSED_PARAM;
VALUE str;
rb_scan_args(argc, argv, "1", &str);
SafeStringValue(str);
Bitmap *b = getPrivateData<Bitmap>(self);
try {
b->saveToFile(RSTRING_PTR(str));
} catch (const Exception &e) {
raiseRbExc(e);
}
return RUBY_Qnil;
}
RB_METHOD(bitmapInitializeCopy)
{
rb_check_argc(argc, 1);
VALUE origObj = argv[0];
if (!OBJ_INIT_COPY(self, origObj))
return self;
Bitmap *orig = getPrivateData<Bitmap>(origObj);
Bitmap *b = 0;
GUARD_EXC( b = new Bitmap(*orig); );
bitmapInitProps(b, self);
b->setFont(orig->getFont());
setPrivateData(self, b);
return self;
}
void
bitmapBindingInit()
{
VALUE klass = rb_define_class("Bitmap", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&BitmapType>);
void bitmapBindingInit() {
VALUE klass = rb_define_class("Bitmap", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&BitmapType>);
#else
rb_define_alloc_func(klass, BitmapAllocate);
rb_define_alloc_func(klass, BitmapAllocate);
#endif
disposableBindingInit<Bitmap>(klass);
disposableBindingInit<Bitmap>(klass);
_rb_define_method(klass, "initialize", bitmapInitialize);
_rb_define_method(klass, "initialize_copy", bitmapInitializeCopy);
_rb_define_method(klass, "initialize", bitmapInitialize);
_rb_define_method(klass, "initialize_copy", bitmapInitializeCopy);
_rb_define_method(klass, "width", bitmapWidth);
_rb_define_method(klass, "height", bitmapHeight);
_rb_define_method(klass, "rect", bitmapRect);
_rb_define_method(klass, "blt", bitmapBlt);
_rb_define_method(klass, "stretch_blt", bitmapStretchBlt);
_rb_define_method(klass, "fill_rect", bitmapFillRect);
_rb_define_method(klass, "clear", bitmapClear);
_rb_define_method(klass, "get_pixel", bitmapGetPixel);
_rb_define_method(klass, "set_pixel", bitmapSetPixel);
_rb_define_method(klass, "hue_change", bitmapHueChange);
_rb_define_method(klass, "draw_text", bitmapDrawText);
_rb_define_method(klass, "text_size", bitmapTextSize);
_rb_define_method(klass, "raw_data", bitmapGetRawData);
_rb_define_method(klass, "raw_data=", bitmapSetRawData);
_rb_define_method(klass, "to_file", bitmapSaveToFile);
_rb_define_method(klass, "width", bitmapWidth);
_rb_define_method(klass, "height", bitmapHeight);
_rb_define_method(klass, "rect", bitmapRect);
_rb_define_method(klass, "blt", bitmapBlt);
_rb_define_method(klass, "stretch_blt", bitmapStretchBlt);
_rb_define_method(klass, "fill_rect", bitmapFillRect);
_rb_define_method(klass, "clear", bitmapClear);
_rb_define_method(klass, "get_pixel", bitmapGetPixel);
_rb_define_method(klass, "set_pixel", bitmapSetPixel);
_rb_define_method(klass, "hue_change", bitmapHueChange);
_rb_define_method(klass, "draw_text", bitmapDrawText);
_rb_define_method(klass, "text_size", bitmapTextSize);
_rb_define_method(klass, "gradient_fill_rect", bitmapGradientFillRect);
_rb_define_method(klass, "clear_rect", bitmapClearRect);
_rb_define_method(klass, "blur", bitmapBlur);
_rb_define_method(klass, "radial_blur", bitmapRadialBlur);
_rb_define_method(klass, "raw_data", bitmapGetRawData);
_rb_define_method(klass, "raw_data=", bitmapSetRawData);
_rb_define_method(klass, "to_file", bitmapSaveToFile);
INIT_PROP_BIND(Bitmap, Font, "font");
_rb_define_method(klass, "gradient_fill_rect", bitmapGradientFillRect);
_rb_define_method(klass, "clear_rect", bitmapClearRect);
_rb_define_method(klass, "blur", bitmapBlur);
_rb_define_method(klass, "radial_blur", bitmapRadialBlur);
INIT_PROP_BIND(Bitmap, Font, "font");
}

470
binding/discord-binding.cpp
View file

@ -1,251 +1,226 @@
#include <discord_game_sdk.h>
#include "binding-types.h"
#include "binding-util.h"
#include "discordstate.h"
#include "sharedstate.h"
#include "binding-util.h"
#include "binding-types.h"
//NYI
void discordResultCb(void *callback_data, enum EDiscordResult result)
{
}
// NYI
void discordResultCb(void *callback_data, enum EDiscordResult result) {}
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE_CUSTOMFREE(DCActivity, free);
#else
DEF_ALLOCFUNC_CUSTOMFREE(DCActivity, free);
#endif
RB_METHOD(DiscordConnected)
{
RB_UNUSED_PARAM;
// Checking to make sure callbacks have actually fired
return rb_bool_new(shState->discord().userId());
RB_METHOD(DiscordConnected) {
RB_UNUSED_PARAM;
// Checking to make sure callbacks have actually fired
return rb_bool_new(shState->discord().userId());
}
RB_METHOD(DiscordGetUsername)
{
RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userName().c_str());
RB_METHOD(DiscordGetUsername) {
RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userName().c_str());
}
RB_METHOD(DiscordGetDiscriminator)
{
RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userDiscrim().c_str());
RB_METHOD(DiscordGetDiscriminator) {
RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userDiscrim().c_str());
}
RB_METHOD(DiscordGetUserId)
{
RB_UNUSED_PARAM;
return LL2NUM(shState->discord().userId());
RB_METHOD(DiscordGetUserId) {
RB_UNUSED_PARAM;
return LL2NUM(shState->discord().userId());
}
void bitmapInitProps(Bitmap *b, VALUE self);
RB_METHOD(DiscordGetUserAvatar)
{
RB_UNUSED_PARAM;
int size = 32;
rb_get_args(argc, argv, "|i", &size RB_ARG_END);
Bitmap *result = shState->discord().userAvatar(size);
if (!result) return RUBY_Qnil;
VALUE ret = wrapObject(result, BitmapType);
bitmapInitProps(result, ret);
return ret;
RB_METHOD(DiscordGetUserAvatar) {
RB_UNUSED_PARAM;
int size = 32;
rb_get_args(argc, argv, "|i", &size RB_ARG_END);
Bitmap *result = shState->discord().userAvatar(size);
if (!result)
return RUBY_Qnil;
VALUE ret = wrapObject(result, BitmapType);
bitmapInitProps(result, ret);
return ret;
}
RB_METHOD(DiscordActivitySend)
{
RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager();
DiscordActivity *activity = getPrivateData<DiscordActivity>(self);
if (am) am->update_activity(am, activity, 0, discordResultCb);
return Qnil;
RB_METHOD(DiscordActivitySend) {
RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager();
DiscordActivity *activity = getPrivateData<DiscordActivity>(self);
if (am)
am->update_activity(am, activity, 0, discordResultCb);
return Qnil;
}
RB_METHOD(DiscordActivityInitialize)
{
RB_UNUSED_PARAM;
DiscordActivity *activity = ALLOC(DiscordActivity);
setPrivateData(self, activity);
memset(activity, 0, sizeof(DiscordActivity));
activity->type = DiscordActivityType_Playing;
if (rb_block_given_p())
{
rb_yield(self);
DiscordActivitySend(0, 0, self);
};
RB_METHOD(DiscordActivityInitialize) {
RB_UNUSED_PARAM;
DiscordActivity *activity = ALLOC(DiscordActivity);
setPrivateData(self, activity);
memset(activity, 0, sizeof(DiscordActivity));
activity->type = DiscordActivityType_Playing;
if (rb_block_given_p()) {
rb_yield(self);
DiscordActivitySend(0, 0, self);
};
return self;
}
RB_METHOD(DiscordActivityInitializeCopy) {
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
VALUE origObj = argv[0];
if (!OBJ_INIT_COPY(self, origObj))
return self;
DiscordActivity *orig = getPrivateData<DiscordActivity>(origObj);
DiscordActivity *s = ALLOC(DiscordActivity);
memcpy(s, orig, sizeof(DiscordActivity));
setPrivateData(self, s);
return self;
}
RB_METHOD(DiscordActivityInitializeCopy)
{
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
VALUE origObj = argv[0];
if (!OBJ_INIT_COPY(self, origObj))
return self;
DiscordActivity *orig = getPrivateData<DiscordActivity>(origObj);
DiscordActivity *s = ALLOC(DiscordActivity);
memcpy(s, orig, sizeof(DiscordActivity));
setPrivateData(self, s);
return self;
RB_METHOD(DiscordActivityClear) {
RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager();
if (am)
am->clear_activity(am, 0, discordResultCb);
return Qnil;
}
RB_METHOD(DiscordActivityClear)
{
RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager();
if (am) am->clear_activity(am, 0, discordResultCb);
return Qnil;
}
#define DEF_DCPROP_ACTPARTYSZ(n) \
RB_METHOD(DiscordActivityGetParty##n) \
{ \
RB_UNUSED_PARAM; \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
return INT2NUM(p->party.size.n); \
} \
RB_METHOD(DiscordActivitySetParty##n) \
{ \
RB_UNUSED_PARAM; \
int num; \
rb_get_args(argc, argv, "i", &num); \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
p->party.size.n = num; \
return INT2NUM(num); \
}
#define DEF_DCPROP_ACTPARTYSZ(n) \
RB_METHOD(DiscordActivityGetParty##n) { \
RB_UNUSED_PARAM; \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
return INT2NUM(p->party.size.n); \
} \
RB_METHOD(DiscordActivitySetParty##n) { \
RB_UNUSED_PARAM; \
int num; \
rb_get_args(argc, argv, "i", &num); \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
p->party.size.n = num; \
return INT2NUM(num); \
}
DEF_DCPROP_ACTPARTYSZ(current_size);
DEF_DCPROP_ACTPARTYSZ(max_size);
#define DEF_DCPROP_S(basename, propname, maxsz) \
RB_METHOD(Discord##basename##Get##propname) \
{ \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_str_new_cstr(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) \
{ \
RB_UNUSED_PARAM; \
VALUE str; \
rb_scan_args(argc, argv, "1", &str); \
SafeStringValue(str); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
strncpy(p->propname, RSTRING_PTR(str), maxsz); \
return str; \
}
#define DEF_DCPROP_S(basename, propname, maxsz) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_str_new_cstr(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
VALUE str; \
rb_scan_args(argc, argv, "1", &str); \
SafeStringValue(str); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
strncpy(p->propname, RSTRING_PTR(str), maxsz); \
return str; \
}
#define DEF_DCPROP_S_SUB(basename, subname, propname, maxsz) \
RB_METHOD(Discord##basename##Get##subname##_##propname) \
{ \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_str_new_cstr(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##subname##_##propname) \
{ \
RB_UNUSED_PARAM; \
VALUE str; \
rb_scan_args(argc, argv, "1", &str); \
SafeStringValue(str); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
strncpy(p->subname.propname, RSTRING_PTR(str), maxsz); \
return str; \
}
#define DEF_DCPROP_S_SUB(basename, subname, propname, maxsz) \
RB_METHOD(Discord##basename##Get##subname##_##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_str_new_cstr(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##subname##_##propname) { \
RB_UNUSED_PARAM; \
VALUE str; \
rb_scan_args(argc, argv, "1", &str); \
SafeStringValue(str); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
strncpy(p->subname.propname, RSTRING_PTR(str), maxsz); \
return str; \
}
#define DEF_DCPROP_I(basename, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##propname) \
{ \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return convtype##2NUM(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) \
{ \
RB_UNUSED_PARAM; \
VALUE num; \
rb_scan_args(argc, argv, "1", &num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->propname = (cast)NUM2##convtype(num); \
return num; \
}
#define DEF_DCPROP_I(basename, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return convtype##2NUM(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
VALUE num; \
rb_scan_args(argc, argv, "1", &num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->propname = (cast)NUM2##convtype(num); \
return num; \
}
#define DEF_DCPROP_I_SUB(basename, subname, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##subname##_##propname) \
{ \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return convtype##2NUM(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##subname##_##propname) \
{ \
RB_UNUSED_PARAM; \
VALUE num; \
rb_scan_args(argc, argv, "1", &num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->subname.propname = (cast)NUM2##convtype(num); \
return num; \
}
#define DEF_DCPROP_I_SUB(basename, subname, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##subname##_##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return convtype##2NUM(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##subname##_##propname) { \
RB_UNUSED_PARAM; \
VALUE num; \
rb_scan_args(argc, argv, "1", &num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->subname.propname = (cast)NUM2##convtype(num); \
return num; \
}
#define DEF_DCPROP_B(basename, propname) \
RB_METHOD(Discord##basename##Get##propname) \
{ \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_bool_new(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) \
{ \
RB_UNUSED_PARAM; \
bool b; \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->propname = b; \
return rb_bool_new(b); \
}
#define DEF_DCPROP_B(basename, propname) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_bool_new(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
bool b; \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->propname = b; \
return rb_bool_new(b); \
}
#define DEF_DCPROP_B_SUB(basename, propname, subname) \
RB_METHOD(Discord##basename##Get##propname) \
{ \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_bool_new(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##propname) \
{ \
RB_UNUSED_PARAM; \
bool b; \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->subname.propname = b; \
return rb_bool_new(b); \
}
#define DEF_DCPROP_B_SUB(basename, propname, subname) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_bool_new(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
bool b; \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->subname.propname = b; \
return rb_bool_new(b); \
}
DEF_DCPROP_S(Activity, state, 128);
DEF_DCPROP_S(Activity, details, 128);
@ -260,47 +235,46 @@ DEF_DCPROP_I_SUB(Activity, timestamps, start, LL, DiscordTimestamp);
DEF_DCPROP_I_SUB(Activity, timestamps, end, LL, DiscordTimestamp);
DEF_DCPROP_B(Activity, instance);
#define BIND_DCPROP(basename, b, f) \
_rb_define_method(activityClass, b, Discord##basename##Get##f); \
_rb_define_method(activityClass, b "=", Discord##basename##Set##f);
#define BIND_DCPROP(basename, b, f) \
_rb_define_method(activityClass, b, Discord##basename##Get##f); \
_rb_define_method(activityClass, b "=", Discord##basename##Set##f);
void DiscordBindingInit() {
VALUE mod = rb_define_module("Discord");
_rb_define_module_function(mod, "connected?", DiscordConnected);
_rb_define_module_function(mod, "user_name", DiscordGetUsername);
_rb_define_module_function(mod, "user_discriminator",
DiscordGetDiscriminator);
_rb_define_module_function(mod, "user_id", DiscordGetUserId);
_rb_define_module_function(mod, "user_avatar", DiscordGetUserAvatar);
void DiscordBindingInit()
{
VALUE mod = rb_define_module("Discord");
_rb_define_module_function(mod, "connected?", DiscordConnected);
_rb_define_module_function(mod, "user_name", DiscordGetUsername);
_rb_define_module_function(mod, "user_discriminator", DiscordGetDiscriminator);
_rb_define_module_function(mod, "user_id", DiscordGetUserId);
_rb_define_module_function(mod, "user_avatar", DiscordGetUserAvatar);
VALUE activityClass = rb_define_class_under(mod, "Activity", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(activityClass, classAllocate<&DCActivityType>);
VALUE activityClass = rb_define_class_under(mod, "Activity", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(activityClass, classAllocate<&DCActivityType>);
#else
rb_define_alloc_func(activityClass, DCActivityAllocate);
rb_define_alloc_func(activityClass, DCActivityAllocate);
#endif
_rb_define_method(activityClass, "initialize", DiscordActivityInitialize);
_rb_define_method(activityClass, "initialize_copy", DiscordActivityInitializeCopy);
rb_define_class_method(activityClass, "clear", DiscordActivityClear);
_rb_define_method(activityClass, "send", DiscordActivitySend);
BIND_DCPROP(Activity, "state", state);
BIND_DCPROP(Activity, "details", details);
BIND_DCPROP(Activity, "large_image", assets_large_image);
BIND_DCPROP(Activity, "large_text", assets_large_text);
BIND_DCPROP(Activity, "small_image", assets_small_image);
BIND_DCPROP(Activity, "small_text", assets_small_text);
BIND_DCPROP(Activity, "party_id", party_id);
BIND_DCPROP(Activity, "party_currentsize", Partycurrent_size);
BIND_DCPROP(Activity, "party_maxsize", Partymax_size);
BIND_DCPROP(Activity, "type", type);
BIND_DCPROP(Activity, "start_time", timestamps_start);
BIND_DCPROP(Activity, "end_time", timestamps_end);
BIND_DCPROP(Activity, "instance", instance);
_rb_define_method(activityClass, "initialize", DiscordActivityInitialize);
_rb_define_method(activityClass, "initialize_copy",
DiscordActivityInitializeCopy);
rb_define_class_method(activityClass, "clear", DiscordActivityClear);
_rb_define_method(activityClass, "send", DiscordActivitySend);
BIND_DCPROP(Activity, "state", state);
BIND_DCPROP(Activity, "details", details);
BIND_DCPROP(Activity, "large_image", assets_large_image);
BIND_DCPROP(Activity, "large_text", assets_large_text);
BIND_DCPROP(Activity, "small_image", assets_small_image);
BIND_DCPROP(Activity, "small_text", assets_small_text);
BIND_DCPROP(Activity, "party_id", party_id);
BIND_DCPROP(Activity, "party_currentsize", Partycurrent_size);
BIND_DCPROP(Activity, "party_maxsize", Partymax_size);
BIND_DCPROP(Activity, "type", type);
BIND_DCPROP(Activity, "start_time", timestamps_start);
BIND_DCPROP(Activity, "end_time", timestamps_end);
BIND_DCPROP(Activity, "instance", instance);
}

376
binding/etc-binding.cpp
View file

@ -19,12 +19,12 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "etc.h"
#include "binding-util.h"
#include "etc.h"
#include "serializable-binding.h"
#include "sharedstate.h"
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE(Color);
DEF_TYPE(Tone);
DEF_TYPE(Rect);
@ -34,24 +34,23 @@ DEF_ALLOCFUNC(Tone);
DEF_ALLOCFUNC(Rect);
#endif
#define ATTR_RW(Klass, Attr, arg_type, arg_t_s, value_fun) \
RB_METHOD(Klass##Get##Attr) \
{ \
RB_UNUSED_PARAM \
Klass *p = getPrivateData<Klass>(self); \
return value_fun(p->get##Attr()); \
} \
RB_METHOD(Klass##Set##Attr) \
{ \
Klass *p = getPrivateData<Klass>(self); \
arg_type arg; \
rb_get_args(argc, argv, arg_t_s, &arg RB_ARG_END); \
p->set##Attr(arg); \
return *argv; \
}
#define ATTR_RW(Klass, Attr, arg_type, arg_t_s, value_fun) \
RB_METHOD(Klass##Get##Attr) { \
RB_UNUSED_PARAM \
Klass *p = getPrivateData<Klass>(self); \
return value_fun(p->get##Attr()); \
} \
RB_METHOD(Klass##Set##Attr) { \
Klass *p = getPrivateData<Klass>(self); \
arg_type arg; \
rb_get_args(argc, argv, arg_t_s, &arg RB_ARG_END); \
p->set##Attr(arg); \
return *argv; \
}
#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_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)
ATTR_DOUBLE_RW(Color, Red)
ATTR_DOUBLE_RW(Color, Green)
@ -68,161 +67,137 @@ ATTR_INT_RW(Rect, Y)
ATTR_INT_RW(Rect, Width)
ATTR_INT_RW(Rect, Height)
#ifndef OLD_RUBY
#define EQUAL_FUN(Klass) \
RB_METHOD(Klass##Equal) \
{ \
Klass *p = getPrivateData<Klass>(self); \
VALUE otherObj; \
Klass *other; \
rb_get_args(argc, argv, "o", &otherObj RB_ARG_END); \
if (rgssVer >= 3) \
if (!rb_typeddata_is_kind_of(otherObj, &Klass##Type)) \
return Qfalse; \
other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \
return rb_bool_new(*p == *other); \
}
#if RAPI_FULL > 187
#define EQUAL_FUN(Klass) \
RB_METHOD(Klass##Equal) { \
Klass *p = getPrivateData<Klass>(self); \
VALUE otherObj; \
Klass *other; \
rb_get_args(argc, argv, "o", &otherObj RB_ARG_END); \
if (rgssVer >= 3) \
if (!rb_typeddata_is_kind_of(otherObj, &Klass##Type)) \
return Qfalse; \
other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \
return rb_bool_new(*p == *other); \
}
#else
#define EQUAL_FUN(Klass) \
RB_METHOD(Klass##Equal) \
{ \
Klass *p = getPrivateData<Klass>(self); \
VALUE otherObj; \
Klass *other; \
rb_get_args(argc, argv, "o", &otherObj RB_ARG_END); \
return Qfalse; \
other = getPrivateDataCheck<Klass>(otherObj, #Klass); \
return rb_bool_new(*p == *other); \
}
#define EQUAL_FUN(Klass) \
RB_METHOD(Klass##Equal) { \
Klass *p = getPrivateData<Klass>(self); \
VALUE otherObj; \
Klass *other; \
rb_get_args(argc, argv, "o", &otherObj RB_ARG_END); \
return Qfalse; \
other = getPrivateDataCheck<Klass>(otherObj, #Klass); \
return rb_bool_new(*p == *other); \
}
#endif
EQUAL_FUN(Color)
EQUAL_FUN(Tone)
EQUAL_FUN(Rect)
#define INIT_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Initialize) \
{ \
Klass *k; \
if (argc == 0) \
{ \
k = new Klass(); \
} \
else \
{ \
param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k = new Klass(p1, p2, p3, p4); \
} \
setPrivateData(self, k); \
return self; \
}
#define INIT_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Initialize) { \
Klass *k; \
if (argc == 0) { \
k = new Klass(); \
} else { \
param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k = new Klass(p1, p2, p3, p4); \
} \
setPrivateData(self, k); \
return self; \
}
INIT_FUN(Color, double, "fff|f", 255)
INIT_FUN(Tone, double, "fff|f", 0)
INIT_FUN(Rect, int, "iiii", 0)
#ifndef OLD_RUBY
#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Set) \
{ \
Klass *k = getPrivateData<Klass>(self); \
if (argc == 1) \
{ \
VALUE otherObj = argv[0]; \
Klass *other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \
*k = *other; \
} \
else \
{ \
param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k->set(p1, p2, p3, p4); \
} \
return self; \
}
#if RAPI_FULL > 187
#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Set) { \
Klass *k = getPrivateData<Klass>(self); \
if (argc == 1) { \
VALUE otherObj = argv[0]; \
Klass *other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \
*k = *other; \
} else { \
param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k->set(p1, p2, p3, p4); \
} \
return self; \
}
#else
#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Set) \
{ \
Klass *k = getPrivateData<Klass>(self); \
if (argc == 1) \
{ \
VALUE otherObj = argv[0]; \
Klass *other = getPrivateDataCheck<Klass>(otherObj, #Klass); \
*k = *other; \
} \
else \
{ \
param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k->set(p1, p2, p3, p4); \
} \
return self; \
}
#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
RB_METHOD(Klass##Set) { \
Klass *k = getPrivateData<Klass>(self); \
if (argc == 1) { \
VALUE otherObj = argv[0]; \
Klass *other = getPrivateDataCheck<Klass>(otherObj, #Klass); \
*k = *other; \
} else { \
param_type p1, p2, p3, p4 = last_param_def; \
rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4 RB_ARG_END); \
k->set(p1, p2, p3, p4); \
} \
return self; \
}
#endif
SET_FUN(Color, double, "fff|f", 255)
SET_FUN(Tone, double, "fff|f", 0)
SET_FUN(Rect, int, "iiii", 0)
RB_METHOD(rectEmpty)
{
RB_UNUSED_PARAM;
Rect *r = getPrivateData<Rect>(self);
r->empty();
return self;
RB_METHOD(rectEmpty) {
RB_UNUSED_PARAM;
Rect *r = getPrivateData<Rect>(self);
r->empty();
return self;
}
RB_METHOD(ColorStringify)
{
RB_UNUSED_PARAM;
RB_METHOD(ColorStringify) {
RB_UNUSED_PARAM;
Color *c = getPrivateData<Color>(self);
#ifndef OLD_RUBY
return rb_sprintf("(%f, %f, %f, %f)",
c->red, c->green, c->blue, c->alpha);
Color *c = getPrivateData<Color>(self);
#if RAPI_FULL > 187
return rb_sprintf("(%f, %f, %f, %f)", c->red, c->green, c->blue, c->alpha);
#else
char buf[50] = {0};
sprintf((char*)&buf, "(%f, %f, %f, %f)",
c->red, c->green, c->blue, c->alpha);
return rb_str_new2(buf);
char buf[50] = {0};
sprintf((char *)&buf, "(%f, %f, %f, %f)", c->red, c->green, c->blue,
c->alpha);
return rb_str_new2(buf);
#endif
}
RB_METHOD(ToneStringify)
{
RB_UNUSED_PARAM;
RB_METHOD(ToneStringify) {
RB_UNUSED_PARAM;
Tone *t = getPrivateData<Tone>(self);
Tone *t = getPrivateData<Tone>(self);
#ifndef OLD_RUBY
return rb_sprintf("(%f, %f, %f, %f)",
t->red, t->green, t->blue, t->gray);
#if RAPI_FULL > 187
return rb_sprintf("(%f, %f, %f, %f)", t->red, t->green, t->blue, t->gray);
#else
char buf[50] = {0};
sprintf((char*)&buf, "(%f, %f, %f, %f)",
t->red, t->green, t->blue, t->gray);
return rb_str_new2(buf);
char buf[50] = {0};
sprintf((char *)&buf, "(%f, %f, %f, %f)", t->red, t->green, t->blue, t->gray);
return rb_str_new2(buf);
#endif
}
RB_METHOD(RectStringify)
{
RB_UNUSED_PARAM;
RB_METHOD(RectStringify) {
RB_UNUSED_PARAM;
Rect *r = getPrivateData<Rect>(self);
Rect *r = getPrivateData<Rect>(self);
#ifndef OLD_RUBY
return rb_sprintf("(%d, %d, %d, %d)",
r->x, r->y, r->width, r->height);
#if RAPI_FULL > 187
return rb_sprintf("(%d, %d, %d, %d)", r->x, r->y, r->width, r->height);
#else
char buf[50] = {0};
sprintf((char*)&buf, "(%d, %d, %d, %d)",
r->x, r->y, r->width, r->height);
return rb_str_new2(buf);
char buf[50] = {0};
sprintf((char *)&buf, "(%d, %d, %d, %d)", r->x, r->y, r->width, r->height);
return rb_str_new2(buf);
#endif
}
MARSH_LOAD_FUN(Color)
@ -233,73 +208,82 @@ INITCOPY_FUN(Tone)
INITCOPY_FUN(Color)
INITCOPY_FUN(Rect)
#ifndef OLD_RUBY
#define INIT_BIND(Klass) \
{ \
klass = rb_define_class(#Klass, rb_cObject); \
rb_define_alloc_func(klass, classAllocate<&Klass##Type>); \
rb_define_class_method(klass, "_load", Klass##Load); \
serializableBindingInit<Klass>(klass); \
_rb_define_method(klass, "initialize", Klass##Initialize); \
_rb_define_method(klass, "initialize_copy", Klass##InitializeCopy); \
_rb_define_method(klass, "set", Klass##Set); \
_rb_define_method(klass, "==", Klass##Equal); \
_rb_define_method(klass, "===", Klass##Equal); \
_rb_define_method(klass, "eql?", Klass##Equal); \
_rb_define_method(klass, "to_s", Klass##Stringify); \
_rb_define_method(klass, "inspect", Klass##Stringify); \
}
#if RAPI_FULL > 187
#define INIT_BIND(Klass) \
{ \
klass = rb_define_class(#Klass, rb_cObject); \
rb_define_alloc_func(klass, classAllocate<&Klass##Type>); \
rb_define_class_method(klass, "_load", Klass##Load); \
serializableBindingInit<Klass>(klass); \
_rb_define_method(klass, "initialize", Klass##Initialize); \
_rb_define_method(klass, "initialize_copy", Klass##InitializeCopy); \
_rb_define_method(klass, "set", Klass##Set); \
_rb_define_method(klass, "==", Klass##Equal); \
_rb_define_method(klass, "===", Klass##Equal); \
_rb_define_method(klass, "eql?", Klass##Equal); \
_rb_define_method(klass, "to_s", Klass##Stringify); \
_rb_define_method(klass, "inspect", Klass##Stringify); \
}
#else
#define INIT_BIND(Klass) \
{ \
klass = rb_define_class(#Klass, rb_cObject); \
rb_define_alloc_func(klass, Klass##Allocate); \
rb_define_class_method(klass, "_load", Klass##Load); \
serializableBindingInit<Klass>(klass); \
_rb_define_method(klass, "initialize", Klass##Initialize); \
_rb_define_method(klass, "initialize_copy", Klass##InitializeCopy); \
_rb_define_method(klass, "set", Klass##Set); \
_rb_define_method(klass, "==", Klass##Equal); \
_rb_define_method(klass, "===", Klass##Equal); \
_rb_define_method(klass, "eql?", Klass##Equal); \
_rb_define_method(klass, "to_s", Klass##Stringify); \
_rb_define_method(klass, "inspect", Klass##Stringify); \
}
#define INIT_BIND(Klass) \
{ \
klass = rb_define_class(#Klass, rb_cObject); \
rb_define_alloc_func(klass, Klass##Allocate); \
rb_define_class_method(klass, "_load", Klass##Load); \
serializableBindingInit<Klass>(klass); \
_rb_define_method(klass, "initialize", Klass##Initialize); \
_rb_define_method(klass, "initialize_copy", Klass##InitializeCopy); \
_rb_define_method(klass, "set", Klass##Set); \
_rb_define_method(klass, "==", Klass##Equal); \
_rb_define_method(klass, "===", Klass##Equal); \
_rb_define_method(klass, "eql?", Klass##Equal); \
_rb_define_method(klass, "to_s", Klass##Stringify); \
_rb_define_method(klass, "inspect", Klass##Stringify); \
}
#endif
#define MRB_ATTR_R(Class, attr) mrb_define_method(mrb, klass, #attr, Class##Get_##attr, MRB_ARGS_NONE())
#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 MRB_ATTR_R(Class, attr) \
mrb_define_method(mrb, klass, #attr, Class##Get_##attr, MRB_ARGS_NONE())
#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_W(Klass, Attr, attr) _rb_define_method(klass, #attr "=", Klass##Set##Attr)
#define RB_ATTR_RW(Klass, Attr, attr) \
{ RB_ATTR_R(Klass, Attr, attr); RB_ATTR_W(Klass, Attr, attr); }
#define RB_ATTR_R(Klass, Attr, 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) \
{ \
RB_ATTR_R(Klass, Attr, attr); \
RB_ATTR_W(Klass, Attr, attr); \
}
void
etcBindingInit()
{
VALUE klass;
void etcBindingInit() {
VALUE klass;
INIT_BIND(Color);
INIT_BIND(Color);
RB_ATTR_RW(Color, Red, red);
RB_ATTR_RW(Color, Green, green);
RB_ATTR_RW(Color, Blue, blue);
RB_ATTR_RW(Color, Alpha, alpha);
RB_ATTR_RW(Color, Red, red);
RB_ATTR_RW(Color, Green, green);
RB_ATTR_RW(Color, Blue, blue);
RB_ATTR_RW(Color, Alpha, alpha);
INIT_BIND(Tone);
INIT_BIND(Tone);
RB_ATTR_RW(Tone, Red, red);
RB_ATTR_RW(Tone, Green, green);
RB_ATTR_RW(Tone, Blue, blue);
RB_ATTR_RW(Tone, Gray, gray);
RB_ATTR_RW(Tone, Red, red);
RB_ATTR_RW(Tone, Green, green);
RB_ATTR_RW(Tone, Blue, blue);
RB_ATTR_RW(Tone, Gray, gray);
INIT_BIND(Rect);
INIT_BIND(Rect);
RB_ATTR_RW(Rect, X, x);
RB_ATTR_RW(Rect, Y, y);
RB_ATTR_RW(Rect, Width, width);
RB_ATTR_RW(Rect, Height, height);
_rb_define_method(klass, "empty", rectEmpty);
RB_ATTR_RW(Rect, X, x);
RB_ATTR_RW(Rect, Y, y);
RB_ATTR_RW(Rect, Width, width);
RB_ATTR_RW(Rect, Height, height);
_rb_define_method(klass, "empty", rectEmpty);
}

66
binding/filesystem-binding.cpp
View file

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

381
binding/font-binding.cpp
View file

@ -19,149 +19,133 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "font.h"
#include "binding-util.h"
#include "binding-types.h"
#include "binding-util.h"
#include "exception.h"
#include "font.h"
#include "sharedstate.h"
#include <string.h>
static void collectStrings(VALUE obj, std::vector<std::string> &out) {
if (RB_TYPE_P(obj, RUBY_T_STRING)) {
out.push_back(RSTRING_PTR(obj));
} else if (RB_TYPE_P(obj, RUBY_T_ARRAY)) {
for (long i = 0; i < RARRAY_LEN(obj); ++i) {
VALUE str = rb_ary_entry(obj, i);
static void
collectStrings(VALUE obj, std::vector<std::string> &out)
{
if (RB_TYPE_P(obj, RUBY_T_STRING))
{
out.push_back(RSTRING_PTR(obj));
}
else if (RB_TYPE_P(obj, RUBY_T_ARRAY))
{
for (long i = 0; i < RARRAY_LEN(obj); ++i)
{
VALUE str = rb_ary_entry(obj, i);
/* Non-string objects are tolerated (ignored) */
if (!RB_TYPE_P(str, RUBY_T_STRING))
continue;
/* Non-string objects are tolerated (ignored) */
if (!RB_TYPE_P(str, RUBY_T_STRING))
continue;
out.push_back(RSTRING_PTR(str));
}
}
out.push_back(RSTRING_PTR(str));
}
}
}
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE(Font);
#else
DEF_ALLOCFUNC(Font);
#endif
RB_METHOD(fontDoesExist)
{
RB_UNUSED_PARAM;
RB_METHOD(fontDoesExist) {
RB_UNUSED_PARAM;
const char *name = 0;
VALUE nameObj;
const char *name = 0;
VALUE nameObj;
rb_get_args(argc, argv, "o", &nameObj RB_ARG_END);
rb_get_args(argc, argv, "o", &nameObj RB_ARG_END);
if (RB_TYPE_P(nameObj, RUBY_T_STRING))
name = rb_string_value_cstr(&nameObj);
if (RB_TYPE_P(nameObj, RUBY_T_STRING))
name = rb_string_value_cstr(&nameObj);
return rb_bool_new(Font::doesExist(name));
return rb_bool_new(Font::doesExist(name));
}
RB_METHOD(FontSetName);
RB_METHOD(fontInitialize)
{
VALUE namesObj = Qnil;
int size = 0;
RB_METHOD(fontInitialize) {
VALUE namesObj = Qnil;
int size = 0;
rb_get_args(argc, argv, "|oi", &namesObj, &size RB_ARG_END);
rb_get_args(argc, argv, "|oi", &namesObj, &size RB_ARG_END);
Font *f;
Font *f;
if (NIL_P(namesObj))
{
namesObj = rb_iv_get(rb_obj_class(self), "default_name");
f = new Font(0, size);
}
else
{
std::vector<std::string> names;
collectStrings(namesObj, names);
if (NIL_P(namesObj)) {
namesObj = rb_iv_get(rb_obj_class(self), "default_name");
f = new Font(0, size);
} else {
std::vector<std::string> names;
collectStrings(namesObj, names);
f = new Font(&names, size);
}
f = new Font(&names, size);
}
/* This is semantically wrong; the new Font object should take
* a dup'ed object here in case of an array. Ditto for the setters.
* However the same bug/behavior exists in all RM versions. */
rb_iv_set(self, "name", namesObj);
/* This is semantically wrong; the new Font object should take
* a dup'ed object here in case of an array. Ditto for the setters.
* However the same bug/behavior exists in all RM versions. */
rb_iv_set(self, "name", namesObj);
setPrivateData(self, f);
setPrivateData(self, f);
/* Wrap property objects */
f->initDynAttribs();
/* Wrap property objects */
f->initDynAttribs();
wrapProperty(self, &f->getColor(), "color", ColorType);
wrapProperty(self, &f->getColor(), "color", ColorType);
if (rgssVer >= 3)
wrapProperty(self, &f->getOutColor(), "out_color", ColorType);
if (rgssVer >= 3)
wrapProperty(self, &f->getOutColor(), "out_color", ColorType);
return self;
return self;
}
RB_METHOD(fontInitializeCopy)
{
VALUE origObj;
rb_get_args(argc, argv, "o", &origObj RB_ARG_END);
RB_METHOD(fontInitializeCopy) {
VALUE origObj;
rb_get_args(argc, argv, "o", &origObj RB_ARG_END);
if (!OBJ_INIT_COPY(self, origObj))
return self;
if (!OBJ_INIT_COPY(self, origObj))
return self;
Font *orig = getPrivateData<Font>(origObj);
Font *f = new Font(*orig);
setPrivateData(self, f);
Font *orig = getPrivateData<Font>(origObj);
Font *f = new Font(*orig);
setPrivateData(self, f);
/* Wrap property objects */
f->initDynAttribs();
/* Wrap property objects */
f->initDynAttribs();
wrapProperty(self, &f->getColor(), "color", ColorType);
wrapProperty(self, &f->getColor(), "color", ColorType);
if (rgssVer >= 3)
wrapProperty(self, &f->getOutColor(), "out_color", ColorType);
if (rgssVer >= 3)
wrapProperty(self, &f->getOutColor(), "out_color", ColorType);
return self;
return self;
}
RB_METHOD(FontGetName)
{
RB_UNUSED_PARAM;
RB_METHOD(FontGetName) {
RB_UNUSED_PARAM;
return rb_iv_get(self, "name");
return rb_iv_get(self, "name");
}
RB_METHOD(FontSetName)
{
Font *f = getPrivateData<Font>(self);
RB_METHOD(FontSetName) {
Font *f = getPrivateData<Font>(self);
rb_check_argc(argc, 1);
rb_check_argc(argc, 1);
std::vector<std::string> namesObj;
collectStrings(argv[0], namesObj);
std::vector<std::string> namesObj;
collectStrings(argv[0], namesObj);
f->setName(namesObj);
rb_iv_set(self, "name", argv[0]);
f->setName(namesObj);
rb_iv_set(self, "name", argv[0]);
return argv[0];
return argv[0];
}
template<class C>
static void checkDisposed(VALUE) {}
template <class C> 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_I(Font, Size)
@ -171,166 +155,149 @@ DEF_PROP_B(Font, Italic)
DEF_PROP_B(Font, Shadow)
DEF_PROP_B(Font, Outline)
#define DEF_KLASS_PROP(Klass, type, PropName, param_t_s, value_fun) \
RB_METHOD(Klass##Get##PropName) \
{ \
RB_UNUSED_PARAM; \
return value_fun(Klass::get##PropName()); \
} \
RB_METHOD(Klass##Set##PropName) \
{ \
RB_UNUSED_PARAM; \
type value; \
rb_get_args(argc, argv, param_t_s, &value RB_ARG_END); \
Klass::set##PropName(value); \
return value_fun(value); \
}
#define DEF_KLASS_PROP(Klass, type, PropName, param_t_s, value_fun) \
RB_METHOD(Klass##Get##PropName) { \
RB_UNUSED_PARAM; \
return value_fun(Klass::get##PropName()); \
} \
RB_METHOD(Klass##Set##PropName) { \
RB_UNUSED_PARAM; \
type value; \
rb_get_args(argc, argv, param_t_s, &value RB_ARG_END); \
Klass::set##PropName(value); \
return value_fun(value); \
}
DEF_KLASS_PROP(Font, int, DefaultSize, "i", rb_fix_new)
DEF_KLASS_PROP(Font, bool, DefaultBold, "b", rb_bool_new)
DEF_KLASS_PROP(Font, bool, DefaultItalic, "b", rb_bool_new)
DEF_KLASS_PROP(Font, bool, DefaultShadow, "b", rb_bool_new)
DEF_KLASS_PROP(Font, int, DefaultSize, "i", rb_fix_new)
DEF_KLASS_PROP(Font, bool, DefaultBold, "b", rb_bool_new)
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, DefaultOutline, "b", rb_bool_new)
RB_METHOD(FontGetDefaultOutColor)
{
RB_UNUSED_PARAM;
return rb_iv_get(self, "default_out_color");
RB_METHOD(FontGetDefaultOutColor) {
RB_UNUSED_PARAM;
return rb_iv_get(self, "default_out_color");
}
RB_METHOD(FontSetDefaultOutColor)
{
RB_UNUSED_PARAM;
RB_METHOD(FontSetDefaultOutColor) {
RB_UNUSED_PARAM;
VALUE colorObj;
rb_get_args(argc, argv, "o", &colorObj RB_ARG_END);
VALUE colorObj;
rb_get_args(argc, argv, "o", &colorObj RB_ARG_END);
Color *c = getPrivateDataCheck<Color>(colorObj, ColorType);
Color *c = getPrivateDataCheck<Color>(colorObj, ColorType);
Font::setDefaultOutColor(*c);
Font::setDefaultOutColor(*c);
return colorObj;
return colorObj;
}
RB_METHOD(FontGetDefaultName)
{
RB_UNUSED_PARAM;
RB_METHOD(FontGetDefaultName) {
RB_UNUSED_PARAM;
return rb_iv_get(self, "default_name");
return rb_iv_get(self, "default_name");
}
RB_METHOD(FontSetDefaultName)
{
RB_UNUSED_PARAM;
RB_METHOD(FontSetDefaultName) {
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
rb_check_argc(argc, 1);
std::vector<std::string> namesObj;
collectStrings(argv[0], namesObj);
std::vector<std::string> namesObj;
collectStrings(argv[0], namesObj);
Font::setDefaultName(namesObj, shState->fontState());
rb_iv_set(self, "default_name", argv[0]);
Font::setDefaultName(namesObj, shState->fontState());
rb_iv_set(self, "default_name", argv[0]);
return argv[0];
return argv[0];
}
RB_METHOD(FontGetDefaultColor)
{
RB_UNUSED_PARAM;
return rb_iv_get(self, "default_color");
RB_METHOD(FontGetDefaultColor) {
RB_UNUSED_PARAM;
return rb_iv_get(self, "default_color");
}
RB_METHOD(FontSetDefaultColor) {
RB_UNUSED_PARAM;
RB_METHOD(FontSetDefaultColor)
{
RB_UNUSED_PARAM;
VALUE colorObj;
rb_get_args(argc, argv, "o", &colorObj RB_ARG_END);
VALUE colorObj;
rb_get_args(argc, argv, "o", &colorObj RB_ARG_END);
Color *c = getPrivateDataCheck<Color>(colorObj, ColorType);
Color *c = getPrivateDataCheck<Color>(colorObj, ColorType);
Font::setDefaultColor(*c);
Font::setDefaultColor(*c);
return colorObj;
return colorObj;
}
#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##Set##PropName); \
}
#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##Set##PropName); \
}
void
fontBindingInit()
{
VALUE klass = rb_define_class("Font", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&FontType>);
void fontBindingInit() {
VALUE klass = rb_define_class("Font", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&FontType>);
#else
rb_define_alloc_func(klass, FontAllocate);
rb_define_alloc_func(klass, FontAllocate);
#endif
Font::initDefaultDynAttribs();
wrapProperty(klass, &Font::getDefaultColor(), "default_color", ColorType);
Font::initDefaultDynAttribs();
wrapProperty(klass, &Font::getDefaultColor(), "default_color", ColorType);
/* Initialize default names */
const std::vector<std::string> &defNames = Font::getInitialDefaultNames();
VALUE defNamesObj;
/* Initialize default names */
const std::vector<std::string> &defNames = Font::getInitialDefaultNames();
VALUE defNamesObj;
if (defNames.size() == 1)
{
defNamesObj = rb_str_new_cstr(defNames[0].c_str());
}
else
{
defNamesObj = rb_ary_new2(defNames.size());
if (defNames.size() == 1) {
defNamesObj = rb_str_new_cstr(defNames[0].c_str());
} else {
defNamesObj = rb_ary_new2(defNames.size());
for (size_t i = 0; i < defNames.size(); ++i)
rb_ary_push(defNamesObj, rb_str_new_cstr(defNames[i].c_str()));
}
for (size_t i = 0; i < defNames.size(); ++i)
rb_ary_push(defNamesObj, rb_str_new_cstr(defNames[i].c_str()));
}
rb_iv_set(klass, "default_name", defNamesObj);
rb_iv_set(klass, "default_name", defNamesObj);
if (rgssVer >= 3)
wrapProperty(klass, &Font::getDefaultOutColor(), "default_out_color", ColorType);
if (rgssVer >= 3)
wrapProperty(klass, &Font::getDefaultOutColor(), "default_out_color",
ColorType);
INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");
INIT_KLASS_PROP_BIND(Font, DefaultBold, "default_bold");
INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic");
INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color");
INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");
INIT_KLASS_PROP_BIND(Font, DefaultBold, "default_bold");
INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic");
INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color");
if (rgssVer >= 2)
{
INIT_KLASS_PROP_BIND(Font, DefaultShadow, "default_shadow");
}
if (rgssVer >= 2) {
INIT_KLASS_PROP_BIND(Font, DefaultShadow, "default_shadow");
}
if (rgssVer >= 3)
{
INIT_KLASS_PROP_BIND(Font, DefaultOutline, "default_outline");
INIT_KLASS_PROP_BIND(Font, DefaultOutColor, "default_out_color");
}
if (rgssVer >= 3) {
INIT_KLASS_PROP_BIND(Font, DefaultOutline, "default_outline");
INIT_KLASS_PROP_BIND(Font, DefaultOutColor, "default_out_color");
}
rb_define_class_method(klass, "exist?", fontDoesExist);
rb_define_class_method(klass, "exist?", fontDoesExist);
_rb_define_method(klass, "initialize", fontInitialize);
_rb_define_method(klass, "initialize_copy", fontInitializeCopy);
_rb_define_method(klass, "initialize", fontInitialize);
_rb_define_method(klass, "initialize_copy", fontInitializeCopy);
INIT_PROP_BIND(Font, Name, "name");
INIT_PROP_BIND(Font, Size, "size");
INIT_PROP_BIND(Font, Bold, "bold");
INIT_PROP_BIND(Font, Italic, "italic");
INIT_PROP_BIND(Font, Color, "color");
INIT_PROP_BIND(Font, Name, "name");
INIT_PROP_BIND(Font, Size, "size");
INIT_PROP_BIND(Font, Bold, "bold");
INIT_PROP_BIND(Font, Italic, "italic");
INIT_PROP_BIND(Font, Color, "color");
if (rgssVer >= 2)
{
INIT_PROP_BIND(Font, Shadow, "shadow");
}
if (rgssVer >= 2) {
INIT_PROP_BIND(Font, Shadow, "shadow");
}
if (rgssVer >= 3)
{
INIT_PROP_BIND(Font, Outline, "outline");
INIT_PROP_BIND(Font, OutColor, "out_color");
}
if (rgssVer >= 3) {
INIT_PROP_BIND(Font, Outline, "outline");
INIT_PROP_BIND(Font, OutColor, "out_color");
}
}

600
binding/input-binding.cpp
View file

@ -19,408 +19,364 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "binding-util.h"
#include "exception.h"
#include "input.h"
#include "sharedstate.h"
#include "exception.h"
#include "binding-util.h"
#include "src/util.h"
#include <string>
#include <SDL_joystick.h>
#include <string>
RB_METHOD(inputUpdate)
{
RB_UNUSED_PARAM;
RB_METHOD(inputUpdate) {
RB_UNUSED_PARAM;
shState->input().update();
shState->input().update();
return Qnil;
return Qnil;
}
static int getButtonArg(VALUE *argv)
{
int num;
if (FIXNUM_P(*argv))
{
num = FIX2INT(*argv);
}
else if (SYMBOL_P(*argv) && rgssVer >= 3)
{
VALUE symHash = getRbData()->buttoncodeHash;
#ifndef OLD_RUBY
num = FIX2INT(rb_hash_lookup2(symHash, *argv, INT2FIX(Input::None)));
static int getButtonArg(VALUE *argv) {
int num;
if (FIXNUM_P(*argv)) {
num = FIX2INT(*argv);
} else if (SYMBOL_P(*argv) && rgssVer >= 3) {
VALUE symHash = getRbData()->buttoncodeHash;
#if RAPI_FULL > 187
num = FIX2INT(rb_hash_lookup2(symHash, *argv, INT2FIX(Input::None)));
#else
VALUE res = rb_hash_aref(symHash, *argv);
if (!NIL_P(res))
num = FIX2INT(res);
else
num = Input::None;
VALUE res = rb_hash_aref(symHash, *argv);
if (!NIL_P(res))
num = FIX2INT(res);
else
num = Input::None;
#endif
}
else
{
// FIXME: RMXP allows only few more types that
// don't make sense (symbols in pre 3, floats)
num = 0;
}
} else {
// FIXME: RMXP allows only few more types that
// don't make sense (symbols in pre 3, floats)
num = 0;
}
return num;
return num;
}
static int getScancodeArg(VALUE *argv)
{
const char *scancode = rb_id2name(SYM2ID(*argv));
int code{};
try
{
code = strToScancode[scancode];
}
catch (...)
{
rb_raise(rb_eRuntimeError, "%s is not a valid key.", scancode);
}
return code;
static int getScancodeArg(VALUE *argv) {
const char *scancode = rb_id2name(SYM2ID(*argv));
int code{};
try {
code = strToScancode[scancode];
} catch (...) {
rb_raise(rb_eRuntimeError, "%s is not a valid key.", scancode);
}
return code;
}
RB_METHOD(inputPress)
{
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
VALUE button;
rb_scan_args(argc, argv, "1", &button);
int num{};
if (SYMBOL_P(button))
{
num = getScancodeArg(&button);
return rb_bool_new(shState->input().isPressedEx(num, 0));
}
num = getButtonArg(&button);
RB_METHOD(inputPress) {
RB_UNUSED_PARAM;
return rb_bool_new(shState->input().isPressed(num));
rb_check_argc(argc, 1);
VALUE button;
rb_scan_args(argc, argv, "1", &button);
int num{};
if (SYMBOL_P(button)) {
num = getScancodeArg(&button);
return rb_bool_new(shState->input().isPressedEx(num, 0));
}
num = getButtonArg(&button);
return rb_bool_new(shState->input().isPressed(num));
}
RB_METHOD(inputTrigger)
{
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
RB_METHOD(inputTrigger) {
RB_UNUSED_PARAM;
VALUE button;
rb_scan_args(argc, argv, "1", &button);
int num{};
if (SYMBOL_P(button))
{
num = getScancodeArg(&button);
return rb_bool_new(shState->input().isTriggeredEx(num, 0));
}
num = getButtonArg(&button);
rb_check_argc(argc, 1);
return rb_bool_new(shState->input().isTriggered(num));
VALUE button;
rb_scan_args(argc, argv, "1", &button);
int num{};
if (SYMBOL_P(button)) {
num = getScancodeArg(&button);
return rb_bool_new(shState->input().isTriggeredEx(num, 0));
}
num = getButtonArg(&button);
return rb_bool_new(shState->input().isTriggered(num));
}
RB_METHOD(inputRepeat)
{
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
VALUE button;
rb_scan_args(argc, argv, "1", &button);
int num{};
if (SYMBOL_P(button))
{
num = getScancodeArg(&button);
return rb_bool_new(shState->input().isRepeatedEx(num, 0));
}
num = getButtonArg(&button);
RB_METHOD(inputRepeat) {
RB_UNUSED_PARAM;
return rb_bool_new(shState->input().isRepeated(num));
rb_check_argc(argc, 1);
VALUE button;
rb_scan_args(argc, argv, "1", &button);
int num{};
if (SYMBOL_P(button)) {
num = getScancodeArg(&button);
return rb_bool_new(shState->input().isRepeatedEx(num, 0));
}
num = getButtonArg(&button);
return rb_bool_new(shState->input().isRepeated(num));
}
RB_METHOD(inputPressEx)
{
RB_UNUSED_PARAM;
int num;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
return rb_bool_new(shState->input().isPressedEx(num, 1));
RB_METHOD(inputPressEx) {
RB_UNUSED_PARAM;
int num;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
return rb_bool_new(shState->input().isPressedEx(num, 1));
}
RB_METHOD(inputTriggerEx)
{
RB_UNUSED_PARAM;
int num;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
return rb_bool_new(shState->input().isTriggeredEx(num, 1));
RB_METHOD(inputTriggerEx) {
RB_UNUSED_PARAM;
int num;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
return rb_bool_new(shState->input().isTriggeredEx(num, 1));
}
RB_METHOD(inputRepeatEx)
{
RB_UNUSED_PARAM;
int num;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
return rb_bool_new(shState->input().isRepeatedEx(num, 1));
RB_METHOD(inputRepeatEx) {
RB_UNUSED_PARAM;
int num;
rb_get_args(argc, argv, "i", &num RB_ARG_END);
return rb_bool_new(shState->input().isRepeatedEx(num, 1));
}
RB_METHOD(inputDir4)
{
RB_UNUSED_PARAM;
RB_METHOD(inputDir4) {
RB_UNUSED_PARAM;
return rb_fix_new(shState->input().dir4Value());
return rb_fix_new(shState->input().dir4Value());
}
RB_METHOD(inputDir8)
{
RB_UNUSED_PARAM;
RB_METHOD(inputDir8) {
RB_UNUSED_PARAM;
return rb_fix_new(shState->input().dir8Value());
return rb_fix_new(shState->input().dir8Value());
}
/* Non-standard extensions */
RB_METHOD(inputMouseX)
{
RB_UNUSED_PARAM;
RB_METHOD(inputMouseX) {
RB_UNUSED_PARAM;
return rb_fix_new(shState->input().mouseX());
return rb_fix_new(shState->input().mouseX());
}
RB_METHOD(inputMouseY)
{
RB_UNUSED_PARAM;
RB_METHOD(inputMouseY) {
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 POWERCASE(v,c) \
case SDL_JOYSTICK_POWER_##c: \
v = M_SYMBOL(#c); \
break;
#define POWERCASE(v, c) \
case SDL_JOYSTICK_POWER_##c: \
v = M_SYMBOL(#c); \
break;
RB_METHOD(inputJoystickInfo)
{
RB_UNUSED_PARAM;
if (!shState->input().getJoystickConnected())
return RUBY_Qnil;
VALUE ret = rb_hash_new();
rb_hash_aset(ret, M_SYMBOL("name"), rb_str_new_cstr(shState->input().getJoystickName()));
VALUE power;
switch (shState->input().getJoystickPowerLevel()) {
POWERCASE(power, MAX);
POWERCASE(power, WIRED);
POWERCASE(power, FULL);
POWERCASE(power, MEDIUM);
POWERCASE(power, LOW);
POWERCASE(power, EMPTY);
default:
power = M_SYMBOL("UNKNOWN");
break;
}
rb_hash_aset(ret, M_SYMBOL("power"), power);
return ret;
RB_METHOD(inputJoystickInfo) {
RB_UNUSED_PARAM;
if (!shState->input().getJoystickConnected())
return RUBY_Qnil;
VALUE ret = rb_hash_new();
rb_hash_aset(ret, M_SYMBOL("name"),
rb_str_new_cstr(shState->input().getJoystickName()));
VALUE power;
switch (shState->input().getJoystickPowerLevel()) {
POWERCASE(power, MAX);
POWERCASE(power, WIRED);
POWERCASE(power, FULL);
POWERCASE(power, MEDIUM);
POWERCASE(power, LOW);
POWERCASE(power, EMPTY);
default:
power = M_SYMBOL("UNKNOWN");
break;
}
rb_hash_aset(ret, M_SYMBOL("power"), power);
return ret;
}
#undef POWERCASE
#undef M_SYMBOL
RB_METHOD(inputRumble)
{
RB_UNUSED_PARAM;
VALUE duration, strength, attack, fade;
rb_scan_args(argc, argv, "13", &duration, &strength, &attack, &fade);
int dur = NUM2INT(duration);
int str = (NIL_P(strength)) ? 1 : NUM2INT(strength);
int att = (NIL_P(attack)) ? 0 : NUM2INT(attack);
int fad = (NIL_P(fade)) ? 0 : NUM2INT(fade);
shState->input().rumble(dur, str, att, fad);
return Qnil;
RB_METHOD(inputRumble) {
RB_UNUSED_PARAM;
VALUE duration, strength, attack, fade;
rb_scan_args(argc, argv, "13", &duration, &strength, &attack, &fade);
int dur = NUM2INT(duration);
int str = (NIL_P(strength)) ? 1 : NUM2INT(strength);
int att = (NIL_P(attack)) ? 0 : NUM2INT(attack);
int fad = (NIL_P(fade)) ? 0 : NUM2INT(fade);
shState->input().rumble(dur, str, att, fad);
return Qnil;
}
RB_METHOD(inputGetMode)
{
RB_UNUSED_PARAM;
return rb_bool_new(shState->input().getTextInputMode());
RB_METHOD(inputGetMode) {
RB_UNUSED_PARAM;
return rb_bool_new(shState->input().getTextInputMode());
}
RB_METHOD(inputSetMode)
{
RB_UNUSED_PARAM;
bool mode;
rb_get_args(argc, argv, "b", &mode RB_ARG_END);
shState->input().setTextInputMode(mode);
return mode;
RB_METHOD(inputSetMode) {
RB_UNUSED_PARAM;
bool mode;
rb_get_args(argc, argv, "b", &mode RB_ARG_END);
shState->input().setTextInputMode(mode);
return mode;
}
RB_METHOD(inputGets)
{
RB_UNUSED_PARAM;
VALUE ret = rb_str_new_cstr(shState->input().getText());
shState->input().clearText();
return ret;
RB_METHOD(inputGets) {
RB_UNUSED_PARAM;
VALUE ret = rb_str_new_cstr(shState->input().getText());
shState->input().clearText();
return ret;
}
RB_METHOD(inputGetClipboard)
{
RB_UNUSED_PARAM;
VALUE ret;
try {
ret = rb_str_new_cstr(shState->input().getClipboardText());
} catch (const Exception &e) {
raiseRbExc(e);
}
return ret;
RB_METHOD(inputGetClipboard) {
RB_UNUSED_PARAM;
VALUE ret;
try {
ret = rb_str_new_cstr(shState->input().getClipboardText());
} catch (const Exception &e) {
raiseRbExc(e);
}
return ret;
}
RB_METHOD(inputSetClipboard)
{
RB_UNUSED_PARAM;
VALUE str;
rb_scan_args(argc, argv, "1", &str);
SafeStringValue(str);
try {
shState->input().setClipboardText(RSTRING_PTR(str));
} catch (const Exception &e) {
raiseRbExc(e);
}
return str;
RB_METHOD(inputSetClipboard) {
RB_UNUSED_PARAM;
VALUE str;
rb_scan_args(argc, argv, "1", &str);
SafeStringValue(str);
try {
shState->input().setClipboardText(RSTRING_PTR(str));
} catch (const Exception &e) {
raiseRbExc(e);
}
return str;
}
struct {
const char *str;
Input::ButtonCode val;
} static buttonCodes[] = {{"DOWN", Input::Down},
{"LEFT", Input::Left},
{"RIGHT", Input::Right},
{"UP", Input::Up},
struct
{
const char *str;
Input::ButtonCode val;
}
static buttonCodes[] =
{
{ "DOWN", Input::Down },
{ "LEFT", Input::Left },
{ "RIGHT", Input::Right },
{ "UP", Input::Up },
#ifdef MARIN
{ "ZL", Input::ZL },
{ "ZR", Input::ZR },
{"ZL", Input::ZL},
{"ZR", Input::ZR},
#else
{ "C", Input::ZL },
{ "Z", Input::ZR },
{"C", Input::ZL},
{"Z", Input::ZR},
#endif
{ "A", Input::A },
{ "B", Input::B },
{ "X", Input::X },
{ "Y", Input::Y },
{ "L", Input::L },
{ "R", Input::R },
{"A", Input::A},
{"B", Input::B},
{"X", Input::X},
{"Y", Input::Y},
{"L", Input::L},
{"R", Input::R},
{ "SHIFT", Input::Shift },
{ "CTRL", Input::Ctrl },
{ "ALT", Input::Alt },
{"SHIFT", Input::Shift},
{"CTRL", Input::Ctrl},
{"ALT", Input::Alt},
{ "F5", Input::F5 },
{ "F6", Input::F6 },
{ "F7", Input::F7 },
{ "F8", Input::F8 },
{ "F9", Input::F9 },
{"F5", Input::F5},
{"F6", Input::F6},
{"F7", Input::F7},
{"F8", Input::F8},
{"F9", Input::F9},
{ "MOUSELEFT", Input::MouseLeft },
{ "MOUSEMIDDLE", Input::MouseMiddle },
{ "MOUSERIGHT", Input::MouseRight }
};
{"MOUSELEFT", Input::MouseLeft},
{"MOUSEMIDDLE", Input::MouseMiddle},
{"MOUSERIGHT", Input::MouseRight}};
static elementsN(buttonCodes);
void
inputBindingInit()
{
VALUE module = rb_define_module("Input");
void inputBindingInit() {
VALUE module = rb_define_module("Input");
_rb_define_module_function(module, "update", inputUpdate);
_rb_define_module_function(module, "press?", inputPress);
_rb_define_module_function(module, "trigger?", inputTrigger);
_rb_define_module_function(module, "repeat?", inputRepeat);
_rb_define_module_function(module, "pressex?", inputPressEx);
_rb_define_module_function(module, "triggerex?", inputTriggerEx);
_rb_define_module_function(module, "repeatex?", inputRepeatEx);
_rb_define_module_function(module, "dir4", inputDir4);
_rb_define_module_function(module, "dir8", inputDir8);
_rb_define_module_function(module, "update", inputUpdate);
_rb_define_module_function(module, "press?", inputPress);
_rb_define_module_function(module, "trigger?", inputTrigger);
_rb_define_module_function(module, "repeat?", inputRepeat);
_rb_define_module_function(module, "pressex?", inputPressEx);
_rb_define_module_function(module, "triggerex?", inputTriggerEx);
_rb_define_module_function(module, "repeatex?", inputRepeatEx);
_rb_define_module_function(module, "dir4", inputDir4);
_rb_define_module_function(module, "dir8", inputDir8);
_rb_define_module_function(module, "mouse_x", inputMouseX);
_rb_define_module_function(module, "mouse_y", inputMouseY);
_rb_define_module_function(module, "joystick", inputJoystickInfo);
_rb_define_module_function(module, "rumble", inputRumble);
_rb_define_module_function(module, "text_input", inputGetMode);
_rb_define_module_function(module, "text_input=", inputSetMode);
_rb_define_module_function(module, "gets", inputGets);
_rb_define_module_function(module, "clipboard", inputGetClipboard);
_rb_define_module_function(module, "clipboard=", inputSetClipboard);
_rb_define_module_function(module, "mouse_x", inputMouseX);
_rb_define_module_function(module, "mouse_y", inputMouseY);
if (rgssVer >= 3)
{
VALUE symHash = rb_hash_new();
_rb_define_module_function(module, "joystick", inputJoystickInfo);
_rb_define_module_function(module, "rumble", inputRumble);
for (size_t i = 0; i < buttonCodesN; ++i)
{
ID sym = rb_intern(buttonCodes[i].str);
VALUE val = INT2FIX(buttonCodes[i].val);
_rb_define_module_function(module, "text_input", inputGetMode);
_rb_define_module_function(module, "text_input=", inputSetMode);
_rb_define_module_function(module, "gets", inputGets);
/* In RGSS3 all Input::XYZ constants are equal to :XYZ symbols,
* to be compatible with the previous convention */
rb_const_set(module, sym, ID2SYM(sym));
rb_hash_aset(symHash, ID2SYM(sym), val);
}
_rb_define_module_function(module, "clipboard", inputGetClipboard);
_rb_define_module_function(module, "clipboard=", inputSetClipboard);
rb_iv_set(module, "buttoncodes", symHash);
getRbData()->buttoncodeHash = symHash;
}
else
{
for (size_t i = 0; i < buttonCodesN; ++i)
{
ID sym = rb_intern(buttonCodes[i].str);
VALUE val = INT2FIX(buttonCodes[i].val);
if (rgssVer >= 3) {
VALUE symHash = rb_hash_new();
rb_const_set(module, sym, val);
}
}
for (size_t i = 0; i < buttonCodesN; ++i) {
ID sym = rb_intern(buttonCodes[i].str);
VALUE val = INT2FIX(buttonCodes[i].val);
/* In RGSS3 all Input::XYZ constants are equal to :XYZ symbols,
* to be compatible with the previous convention */
rb_const_set(module, sym, ID2SYM(sym));
rb_hash_aset(symHash, ID2SYM(sym), val);
}
rb_iv_set(module, "buttoncodes", symHash);
getRbData()->buttoncodeHash = symHash;
} else {
for (size_t i = 0; i < buttonCodesN; ++i) {
ID sym = rb_intern(buttonCodes[i].str);
VALUE val = INT2FIX(buttonCodes[i].val);
rb_const_set(module, sym, val);
}
}
}

7
binding/meson.build
View file

@ -1,11 +1,8 @@
if get_option('mri_includes') == ''
ver = get_option('mri_version')
if ver.version_compare('>1.8') == false
add_project_arguments('-DOLD_RUBY', language: ['cpp','objc','objcpp'])
endif
if ver.version_compare('>=2.7') == true
add_project_arguments('-DRUBYCOMPAT=270', language: ['cpp', 'objc', 'objcpp'])
if ver.version_compare('<=1.9')
global_args += '-DLEGACY_RUBY'
endif
global_dependencies += dependency('ruby-' + ver)
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
// Uses LoadLibrary/GetProcAddress on Windows, dlopen/dlsym everywhere else
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
#else
DEF_ALLOCFUNC_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
@ -308,7 +308,7 @@ RB_METHOD(MiniFFI_call) {
void MiniFFIBindingInit() {
VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject);
#ifndef OLD_RUBY
#if RAPI_FULL > 187
rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>);
#else
rb_define_alloc_func(cMiniFFI, MiniFFIAllocate);

66
binding/plane-binding.cpp
View file

@ -19,35 +19,34 @@
** 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-util.h"
#include "disposable-binding.h"
#include "plane.h"
#include "viewportelement-binding.h"
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE(Plane);
#else
DEF_ALLOCFUNC(Plane);
#endif
RB_METHOD(planeInitialize)
{
Plane *p = viewportElementInitialize<Plane>(argc, argv, self);
RB_METHOD(planeInitialize) {
Plane *p = viewportElementInitialize<Plane>(argc, argv, self);
setPrivateData(self, p);
setPrivateData(self, p);
p->initDynAttribs();
p->initDynAttribs();
wrapProperty(self, &p->getColor(), "color", ColorType);
wrapProperty(self, &p->getTone(), "tone", ToneType);
wrapProperty(self, &p->getColor(), "color", ColorType);
wrapProperty(self, &p->getTone(), "tone", ToneType);
return self;
return self;
}
DEF_PROP_OBJ_REF(Plane, Bitmap, Bitmap, "bitmap")
DEF_PROP_OBJ_VAL(Plane, Color, Color, "color")
DEF_PROP_OBJ_VAL(Plane, Tone, Tone, "tone")
DEF_PROP_OBJ_VAL(Plane, Color, Color, "color")
DEF_PROP_OBJ_VAL(Plane, Tone, Tone, "tone")
DEF_PROP_I(Plane, OX)
DEF_PROP_I(Plane, OY)
@ -57,29 +56,26 @@ DEF_PROP_I(Plane, BlendType)
DEF_PROP_F(Plane, ZoomX)
DEF_PROP_F(Plane, ZoomY)
void
planeBindingInit()
{
VALUE klass = rb_define_class("Plane", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&PlaneType>);
void planeBindingInit() {
VALUE klass = rb_define_class("Plane", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&PlaneType>);
#else
rb_define_alloc_func(klass, PlaneAllocate);
rb_define_alloc_func(klass, PlaneAllocate);
#endif
disposableBindingInit<Plane> (klass);
viewportElementBindingInit<Plane>(klass);
disposableBindingInit<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, OX, "ox" );
INIT_PROP_BIND( Plane, OY, "oy" );
INIT_PROP_BIND( Plane, ZoomX, "zoom_x" );
INIT_PROP_BIND( Plane, ZoomY, "zoom_y" );
INIT_PROP_BIND( Plane, Opacity, "opacity" );
INIT_PROP_BIND( Plane, BlendType, "blend_type" );
INIT_PROP_BIND( Plane, Color, "color" );
INIT_PROP_BIND( Plane, Tone, "tone" );
INIT_PROP_BIND(Plane, Bitmap, "bitmap");
INIT_PROP_BIND(Plane, OX, "ox");
INIT_PROP_BIND(Plane, OY, "oy");
INIT_PROP_BIND(Plane, ZoomX, "zoom_x");
INIT_PROP_BIND(Plane, ZoomY, "zoom_y");
INIT_PROP_BIND(Plane, Opacity, "opacity");
INIT_PROP_BIND(Plane, BlendType, "blend_type");
INIT_PROP_BIND(Plane, Color, "color");
INIT_PROP_BIND(Plane, Tone, "tone");
}

132
binding/sprite-binding.cpp
View file

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

208
binding/table-binding.cpp
View file

@ -19,169 +19,155 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include <algorithm>
#include "table.h"
#include "binding-util.h"
#include "serializable-binding.h"
#include "table.h"
#include <algorithm>
static int num2TableSize(VALUE v)
{
int i = NUM2INT(v);
return std::max(0, i);
static int num2TableSize(VALUE v) {
int i = NUM2INT(v);
return std::max(0, i);
}
static void parseArgsTableSizes(int argc, VALUE *argv, int *x, int *y, int *z)
{
*y = *z = 1;
static void parseArgsTableSizes(int argc, VALUE *argv, int *x, int *y, int *z) {
*y = *z = 1;
switch (argc)
{
case 3:
*z = num2TableSize(argv[2]);
/* fall through */
case 2:
*y = num2TableSize(argv[1]);
/* fall through */
case 1:
*x = num2TableSize(argv[0]);
break;
default:
rb_error_arity(argc, 1, 3);
}
switch (argc) {
case 3:
*z = num2TableSize(argv[2]);
/* fall through */
case 2:
*y = num2TableSize(argv[1]);
/* fall through */
case 1:
*x = num2TableSize(argv[0]);
break;
default:
rb_error_arity(argc, 1, 3);
}
}
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE(Table);
#else
DEF_ALLOCFUNC(Table);
#endif
RB_METHOD(tableInitialize)
{
int x, y, z;
RB_METHOD(tableInitialize) {
int x, y, z;
parseArgsTableSizes(argc, argv, &x, &y, &z);
parseArgsTableSizes(argc, argv, &x, &y, &z);
Table *t = new Table(x, y, z);
Table *t = new Table(x, y, z);
setPrivateData(self, t);
setPrivateData(self, t);
return self;
return self;
}
RB_METHOD(tableResize)
{
Table *t = getPrivateData<Table>(self);
RB_METHOD(tableResize) {
Table *t = getPrivateData<Table>(self);
int x, y, z;
parseArgsTableSizes(argc, argv, &x, &y, &z);
int x, y, z;
parseArgsTableSizes(argc, argv, &x, &y, &z);
t->resize(x, y, z);
t->resize(x, y, z);
return Qnil;
return Qnil;
}
#define TABLE_SIZE(d, D) \
RB_METHOD(table##D##Size) \
{ \
RB_UNUSED_PARAM \
Table *t = getPrivateData<Table>(self); \
return INT2NUM(t->d##Size()); \
}
#define TABLE_SIZE(d, D) \
RB_METHOD(table##D##Size) { \
RB_UNUSED_PARAM \
Table *t = getPrivateData<Table>(self); \
return INT2NUM(t->d##Size()); \
}
TABLE_SIZE(x, X)
TABLE_SIZE(y, Y)
TABLE_SIZE(z, Z)
RB_METHOD(tableGetAt)
{
Table *t = getPrivateData<Table>(self);
RB_METHOD(tableGetAt) {
Table *t = getPrivateData<Table>(self);
int x, y, z;
x = y = z = 0;
int x, y, z;
x = y = z = 0;
x = NUM2INT(argv[0]);
if (argc > 1)
y = NUM2INT(argv[1]);
if (argc > 2)
z = NUM2INT(argv[2]);
x = NUM2INT(argv[0]);
if (argc > 1)
y = NUM2INT(argv[1]);
if (argc > 2)
z = NUM2INT(argv[2]);
if (argc > 3)
rb_raise(rb_eArgError, "wrong number of arguments");
if (argc > 3)
rb_raise(rb_eArgError, "wrong number of arguments");
if (x < 0 || x >= t->xSize()
|| y < 0 || y >= t->ySize()
|| z < 0 || z >= t->zSize())
{
return Qnil;
}
if (x < 0 || x >= t->xSize() || y < 0 || y >= t->ySize() || z < 0 ||
z >= t->zSize()) {
return Qnil;
}
short result = t->get(x, y, z);
short result = t->get(x, y, z);
return INT2FIX(result); /* short always fits in a Fixnum */
return INT2FIX(result); /* short always fits in a Fixnum */
}
RB_METHOD(tableSetAt)
{
Table *t = getPrivateData<Table>(self);
RB_METHOD(tableSetAt) {
Table *t = getPrivateData<Table>(self);
int x, y, z, value;
x = y = z = 0;
int x, y, z, value;
x = y = z = 0;
if (argc < 2)
rb_raise(rb_eArgError, "wrong number of arguments");
if (argc < 2)
rb_raise(rb_eArgError, "wrong number of arguments");
switch (argc)
{
default:
case 2 :
x = NUM2INT(argv[0]);
value = NUM2INT(argv[1]);
switch (argc) {
default:
case 2:
x = NUM2INT(argv[0]);
value = NUM2INT(argv[1]);
break;
case 3 :
x = NUM2INT(argv[0]);
y = NUM2INT(argv[1]);
value = NUM2INT(argv[2]);
break;
case 3:
x = NUM2INT(argv[0]);
y = NUM2INT(argv[1]);
value = NUM2INT(argv[2]);
break;
case 4 :
x = NUM2INT(argv[0]);
y = NUM2INT(argv[1]);
z = NUM2INT(argv[2]);
value = NUM2INT(argv[3]);
break;
case 4:
x = NUM2INT(argv[0]);
y = NUM2INT(argv[1]);
z = NUM2INT(argv[2]);
value = NUM2INT(argv[3]);
break;
}
break;
}
t->set(value, x, y, z);
t->set(value, x, y, z);
return argv[argc - 1];
return argv[argc - 1];
}
MARSH_LOAD_FUN(Table)
INITCOPY_FUN(Table)
void
tableBindingInit()
{
VALUE klass = rb_define_class("Table", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&TableType>);
void tableBindingInit() {
VALUE klass = rb_define_class("Table", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TableType>);
#else
rb_define_alloc_func(klass, TableAllocate);
rb_define_alloc_func(klass, TableAllocate);
#endif
serializableBindingInit<Table>(klass);
serializableBindingInit<Table>(klass);
rb_define_class_method(klass, "_load", TableLoad);
_rb_define_method(klass, "initialize", tableInitialize);
_rb_define_method(klass, "initialize_copy", TableInitializeCopy);
_rb_define_method(klass, "resize", tableResize);
_rb_define_method(klass, "xsize", tableXSize);
_rb_define_method(klass, "ysize", tableYSize);
_rb_define_method(klass, "zsize", tableZSize);
_rb_define_method(klass, "[]", tableGetAt);
_rb_define_method(klass, "[]=", tableSetAt);
rb_define_class_method(klass, "_load", TableLoad);
_rb_define_method(klass, "initialize", tableInitialize);
_rb_define_method(klass, "initialize_copy", TableInitializeCopy);
_rb_define_method(klass, "resize", tableResize);
_rb_define_method(klass, "xsize", tableXSize);
_rb_define_method(klass, "ysize", tableYSize);
_rb_define_method(klass, "zsize", tableZSize);
_rb_define_method(klass, "[]", tableGetAt);
_rb_define_method(klass, "[]=", tableSetAt);
}

176
binding/tilemap-binding.cpp
View file

@ -19,166 +19,158 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "tilemap.h"
#include "viewport.h"
#include "bitmap.h"
#include "table.h"
#include "tilemap.h"
#include "viewport.h"
#include "disposable-binding.h"
#include "binding-util.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);
#else
#define TilemapAutotilesType "TilemapAutotiles"
#endif
RB_METHOD(tilemapAutotilesSet)
{
Tilemap::Autotiles *a = getPrivateData<Tilemap::Autotiles>(self);
RB_METHOD(tilemapAutotilesSet) {
Tilemap::Autotiles *a = getPrivateData<Tilemap::Autotiles>(self);
int i;
VALUE bitmapObj;
int i;
VALUE bitmapObj;
rb_get_args(argc, argv, "io", &i, &bitmapObj RB_ARG_END);
rb_get_args(argc, argv, "io", &i, &bitmapObj RB_ARG_END);
Bitmap *bitmap = getPrivateDataCheck<Bitmap>(bitmapObj, BitmapType);
Bitmap *bitmap = getPrivateDataCheck<Bitmap>(bitmapObj, BitmapType);
a->set(i, bitmap);
a->set(i, bitmap);
VALUE ary = rb_iv_get(self, "array");
rb_ary_store(ary, i, bitmapObj);
VALUE ary = rb_iv_get(self, "array");
rb_ary_store(ary, i, bitmapObj);
return self;
return self;
}
RB_METHOD(tilemapAutotilesGet)
{
int i;
rb_get_args (argc, argv, "i", &i RB_ARG_END);
RB_METHOD(tilemapAutotilesGet) {
int i;
rb_get_args(argc, argv, "i", &i RB_ARG_END);
if (i < 0 || i > 6)
return Qnil;
if (i < 0 || i > 6)
return Qnil;
VALUE ary = rb_iv_get(self, "array");
VALUE ary = rb_iv_get(self, "array");
return rb_ary_entry(ary, i);
return rb_ary_entry(ary, i);
}
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE(Tilemap);
#else
DEF_ALLOCFUNC(Tilemap);
#endif
RB_METHOD(tilemapInitialize)
{
Tilemap *t;
RB_METHOD(tilemapInitialize) {
Tilemap *t;
/* Get parameters */
VALUE viewportObj = Qnil;
Viewport *viewport = 0;
/* Get parameters */
VALUE viewportObj = Qnil;
Viewport *viewport = 0;
rb_get_args(argc, argv, "|o", &viewportObj RB_ARG_END);
rb_get_args(argc, argv, "|o", &viewportObj RB_ARG_END);
if (!NIL_P(viewportObj))
viewport = getPrivateDataCheck<Viewport>(viewportObj, ViewportType);
if (!NIL_P(viewportObj))
viewport = getPrivateDataCheck<Viewport>(viewportObj, ViewportType);
/* Construct object */
t = new Tilemap(viewport);
/* Construct object */
t = new Tilemap(viewport);
setPrivateData(self, t);
setPrivateData(self, t);
rb_iv_set(self, "viewport", viewportObj);
rb_iv_set(self, "viewport", viewportObj);
wrapProperty(self, &t->getAutotiles(), "autotiles", TilemapAutotilesType);
wrapProperty(self, &t->getAutotiles(), "autotiles", TilemapAutotilesType);
VALUE autotilesObj = rb_iv_get(self, "autotiles");
VALUE autotilesObj = rb_iv_get(self, "autotiles");
VALUE ary = rb_ary_new2(7);
for (int i = 0; i < 7; ++i)
rb_ary_push(ary, Qnil);
VALUE ary = rb_ary_new2(7);
for (int i = 0; i < 7; ++i)
rb_ary_push(ary, Qnil);
rb_iv_set(autotilesObj, "array", ary);
rb_iv_set(autotilesObj, "array", ary);
/* Circular reference so both objects are always
* alive at the same time */
rb_iv_set(autotilesObj, "tilemap", self);
/* Circular reference so both objects are always
* alive at the same time */
rb_iv_set(autotilesObj, "tilemap", self);
return self;
return self;
}
RB_METHOD(tilemapGetAutotiles)
{
RB_UNUSED_PARAM;
RB_METHOD(tilemapGetAutotiles) {
RB_UNUSED_PARAM;
checkDisposed<Tilemap>(self);
checkDisposed<Tilemap>(self);
return rb_iv_get(self, "autotiles");
return rb_iv_get(self, "autotiles");
}
RB_METHOD(tilemapUpdate)
{
RB_UNUSED_PARAM;
RB_METHOD(tilemapUpdate) {
RB_UNUSED_PARAM;
Tilemap *t = getPrivateData<Tilemap>(self);
Tilemap *t = getPrivateData<Tilemap>(self);
t->update();
t->update();
return Qnil;
return Qnil;
}
RB_METHOD(tilemapGetViewport)
{
RB_UNUSED_PARAM;
RB_METHOD(tilemapGetViewport) {
RB_UNUSED_PARAM;
checkDisposed<Tilemap>(self);
checkDisposed<Tilemap>(self);
return rb_iv_get(self, "viewport");
return rb_iv_get(self, "viewport");
}
DEF_PROP_OBJ_REF(Tilemap, Bitmap, Tileset, "tileset")
DEF_PROP_OBJ_REF(Tilemap, Table, MapData, "map_data")
DEF_PROP_OBJ_REF(Tilemap, Table, FlashData, "flash_data")
DEF_PROP_OBJ_REF(Tilemap, Table, Priorities, "priorities")
DEF_PROP_OBJ_REF(Tilemap, Bitmap, Tileset, "tileset")
DEF_PROP_OBJ_REF(Tilemap, Table, MapData, "map_data")
DEF_PROP_OBJ_REF(Tilemap, Table, FlashData, "flash_data")
DEF_PROP_OBJ_REF(Tilemap, Table, Priorities, "priorities")
DEF_PROP_B(Tilemap, Visible)
DEF_PROP_I(Tilemap, OX)
DEF_PROP_I(Tilemap, OY)
void
tilemapBindingInit()
{
VALUE klass = rb_define_class("TilemapAutotiles", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&TilemapAutotilesType>);
void tilemapBindingInit() {
VALUE klass = rb_define_class("TilemapAutotiles", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TilemapAutotilesType>);
#endif
_rb_define_method(klass, "[]=", tilemapAutotilesSet);
_rb_define_method(klass, "[]", tilemapAutotilesGet);
_rb_define_method(klass, "[]=", tilemapAutotilesSet);
_rb_define_method(klass, "[]", tilemapAutotilesGet);
klass = rb_define_class("Tilemap", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&TilemapType>);
klass = rb_define_class("Tilemap", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TilemapType>);
#else
rb_define_alloc_func(klass, TilemapAllocate);
rb_define_alloc_func(klass, TilemapAllocate);
#endif
disposableBindingInit<Tilemap>(klass);
disposableBindingInit<Tilemap>(klass);
_rb_define_method(klass, "initialize", tilemapInitialize);
_rb_define_method(klass, "autotiles", tilemapGetAutotiles);
_rb_define_method(klass, "update", tilemapUpdate);
_rb_define_method(klass, "initialize", tilemapInitialize);
_rb_define_method(klass, "autotiles", tilemapGetAutotiles);
_rb_define_method(klass, "update", tilemapUpdate);
_rb_define_method(klass, "viewport", tilemapGetViewport);
_rb_define_method(klass, "viewport", tilemapGetViewport);
INIT_PROP_BIND( Tilemap, Tileset, "tileset" );
INIT_PROP_BIND( Tilemap, MapData, "map_data" );
INIT_PROP_BIND( Tilemap, FlashData, "flash_data" );
INIT_PROP_BIND( Tilemap, Priorities, "priorities" );
INIT_PROP_BIND( Tilemap, Visible, "visible" );
INIT_PROP_BIND( Tilemap, OX, "ox" );
INIT_PROP_BIND( Tilemap, OY, "oy" );
INIT_PROP_BIND(Tilemap, Tileset, "tileset");
INIT_PROP_BIND(Tilemap, MapData, "map_data");
INIT_PROP_BIND(Tilemap, FlashData, "flash_data");
INIT_PROP_BIND(Tilemap, Priorities, "priorities");
INIT_PROP_BIND(Tilemap, Visible, "visible");
INIT_PROP_BIND(Tilemap, OX, "ox");
INIT_PROP_BIND(Tilemap, OY, "oy");
}

178
binding/tilemapvx-binding.cpp
View file

@ -19,17 +19,17 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bitmap.h"
#include "sharedstate.h"
#include "table.h"
#include "tilemapvx.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-util.h"
#include "disposable-binding.h"
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE_CUSTOMNAME(TilemapVX, "Tilemap");
DEF_TYPE_CUSTOMFREE(BitmapArray, RUBY_TYPED_NEVER_FREE);
@ -38,143 +38,133 @@ DEF_ALLOCFUNC(TilemapVX);
#define BitmapArrayType "BitmapArray"
#endif
RB_METHOD(tilemapVXInitialize)
{
TilemapVX *t;
RB_METHOD(tilemapVXInitialize) {
TilemapVX *t;
/* Get parameters */
VALUE viewportObj = Qnil;
Viewport *viewport = 0;
/* Get parameters */
VALUE viewportObj = Qnil;
Viewport *viewport = 0;
rb_get_args(argc, argv, "|o", &viewportObj RB_ARG_END);
rb_get_args(argc, argv, "|o", &viewportObj RB_ARG_END);
if (!NIL_P(viewportObj))
viewport = getPrivateDataCheck<Viewport>(viewportObj, ViewportType);
if (!NIL_P(viewportObj))
viewport = getPrivateDataCheck<Viewport>(viewportObj, ViewportType);
/* Construct object */
t = new TilemapVX(viewport);
/* Construct object */
t = new TilemapVX(viewport);
setPrivateData(self, t);
setPrivateData(self, t);
rb_iv_set(self, "viewport", viewportObj);
rb_iv_set(self, "viewport", viewportObj);
wrapProperty(self, &t->getBitmapArray(), "bitmap_array", BitmapArrayType,
rb_const_get(rb_cObject, rb_intern("Tilemap")));
wrapProperty(self, &t->getBitmapArray(), "bitmap_array", BitmapArrayType,
rb_const_get(rb_cObject, rb_intern("Tilemap")));
VALUE autotilesObj = rb_iv_get(self, "bitmap_array");
VALUE autotilesObj = rb_iv_get(self, "bitmap_array");
VALUE ary = rb_ary_new2(9);
for (int i = 0; i < 9; ++i)
rb_ary_push(ary, Qnil);
VALUE ary = rb_ary_new2(9);
for (int i = 0; i < 9; ++i)
rb_ary_push(ary, Qnil);
rb_iv_set(autotilesObj, "array", ary);
rb_iv_set(autotilesObj, "array", ary);
/* Circular reference so both objects are always
* alive at the same time */
rb_iv_set(autotilesObj, "tilemap", self);
/* Circular reference so both objects are always
* alive at the same time */
rb_iv_set(autotilesObj, "tilemap", self);
return self;
return self;
}
RB_METHOD(tilemapVXGetBitmapArray)
{
RB_UNUSED_PARAM;
RB_METHOD(tilemapVXGetBitmapArray) {
RB_UNUSED_PARAM;
checkDisposed<TilemapVX>(self);
checkDisposed<TilemapVX>(self);
return rb_iv_get(self, "bitmap_array");
return rb_iv_get(self, "bitmap_array");
}
RB_METHOD(tilemapVXUpdate)
{
RB_UNUSED_PARAM;
RB_METHOD(tilemapVXUpdate) {
RB_UNUSED_PARAM;
TilemapVX *t = getPrivateData<TilemapVX>(self);
TilemapVX *t = getPrivateData<TilemapVX>(self);
t->update();
t->update();
return Qnil;
return Qnil;
}
DEF_PROP_OBJ_REF(TilemapVX, Viewport, Viewport, "viewport")
DEF_PROP_OBJ_REF(TilemapVX, Table, MapData, "map_data")
DEF_PROP_OBJ_REF(TilemapVX, Table, FlashData, "flash_data")
DEF_PROP_OBJ_REF(TilemapVX, Table, Flags, "flags")
DEF_PROP_OBJ_REF(TilemapVX, Viewport, Viewport, "viewport")
DEF_PROP_OBJ_REF(TilemapVX, Table, MapData, "map_data")
DEF_PROP_OBJ_REF(TilemapVX, Table, FlashData, "flash_data")
DEF_PROP_OBJ_REF(TilemapVX, Table, Flags, "flags")
DEF_PROP_B(TilemapVX, Visible)
DEF_PROP_I(TilemapVX, OX)
DEF_PROP_I(TilemapVX, OY)
RB_METHOD(tilemapVXBitmapsSet)
{
TilemapVX::BitmapArray *a = getPrivateData<TilemapVX::BitmapArray>(self);
RB_METHOD(tilemapVXBitmapsSet) {
TilemapVX::BitmapArray *a = getPrivateData<TilemapVX::BitmapArray>(self);
int i;
VALUE bitmapObj;
int i;
VALUE bitmapObj;
rb_get_args(argc, argv, "io", &i, &bitmapObj RB_ARG_END);
rb_get_args(argc, argv, "io", &i, &bitmapObj RB_ARG_END);
Bitmap *bitmap = getPrivateDataCheck<Bitmap>(bitmapObj, BitmapType);
Bitmap *bitmap = getPrivateDataCheck<Bitmap>(bitmapObj, BitmapType);
a->set(i, bitmap);
a->set(i, bitmap);
VALUE ary = rb_iv_get(self, "array");
rb_ary_store(ary, i, bitmapObj);
VALUE ary = rb_iv_get(self, "array");
rb_ary_store(ary, i, bitmapObj);
return self;
return self;
}
RB_METHOD(tilemapVXBitmapsGet)
{
int i;
rb_get_args (argc, argv, "i", &i RB_ARG_END);
RB_METHOD(tilemapVXBitmapsGet) {
int i;
rb_get_args(argc, argv, "i", &i RB_ARG_END);
if (i < 0 || i > 8)
return Qnil;
if (i < 0 || i > 8)
return Qnil;
VALUE ary = rb_iv_get(self, "array");
VALUE ary = rb_iv_get(self, "array");
return rb_ary_entry(ary, i);
return rb_ary_entry(ary, i);
}
void
tilemapVXBindingInit()
{
VALUE klass = rb_define_class("Tilemap", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&TilemapVXType>);
void tilemapVXBindingInit() {
VALUE klass = rb_define_class("Tilemap", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&TilemapVXType>);
#else
rb_define_alloc_func(klass, TilemapVXAllocate);
rb_define_alloc_func(klass, TilemapVXAllocate);
#endif
disposableBindingInit<TilemapVX>(klass);
disposableBindingInit<TilemapVX>(klass);
_rb_define_method(klass, "initialize", tilemapVXInitialize);
_rb_define_method(klass, "bitmaps", tilemapVXGetBitmapArray);
_rb_define_method(klass, "update", tilemapVXUpdate);
_rb_define_method(klass, "initialize", tilemapVXInitialize);
_rb_define_method(klass, "bitmaps", tilemapVXGetBitmapArray);
_rb_define_method(klass, "update", tilemapVXUpdate);
INIT_PROP_BIND( TilemapVX, Viewport, "viewport" );
INIT_PROP_BIND( TilemapVX, MapData, "map_data" );
INIT_PROP_BIND( TilemapVX, FlashData, "flash_data" );
INIT_PROP_BIND( TilemapVX, Visible, "visible" );
INIT_PROP_BIND( TilemapVX, OX, "ox" );
INIT_PROP_BIND( TilemapVX, OY, "oy" );
INIT_PROP_BIND(TilemapVX, Viewport, "viewport");
INIT_PROP_BIND(TilemapVX, MapData, "map_data");
INIT_PROP_BIND(TilemapVX, FlashData, "flash_data");
INIT_PROP_BIND(TilemapVX, Visible, "visible");
INIT_PROP_BIND(TilemapVX, OX, "ox");
INIT_PROP_BIND(TilemapVX, OY, "oy");
if (rgssVer == 3)
{
INIT_PROP_BIND( TilemapVX, Flags, "flags" );
}
else
{
INIT_PROP_BIND( TilemapVX, Flags, "passages" );
}
if (rgssVer == 3) {
INIT_PROP_BIND(TilemapVX, Flags, "flags");
} else {
INIT_PROP_BIND(TilemapVX, Flags, "passages");
}
klass = rb_define_class_under(klass, "BitmapArray", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&BitmapArrayType>);
klass = rb_define_class_under(klass, "BitmapArray", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&BitmapArrayType>);
#endif
_rb_define_method(klass, "[]=", tilemapVXBitmapsSet);
_rb_define_method(klass, "[]", tilemapVXBitmapsGet);
_rb_define_method(klass, "[]=", tilemapVXBitmapsSet);
_rb_define_method(klass, "[]", tilemapVXBitmapsGet);
}

108
binding/viewport-binding.cpp
View file

@ -19,95 +19,85 @@
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "viewport.h"
#include "sharedstate.h"
#include "binding-types.h"
#include "binding-util.h"
#include "disposable-binding.h"
#include "flashable-binding.h"
#include "sceneelement-binding.h"
#include "binding-util.h"
#include "binding-types.h"
#include "sharedstate.h"
#include "viewport.h"
#ifndef OLD_RUBY
#if RAPI_FULL > 187
DEF_TYPE(Viewport);
#else
DEF_ALLOCFUNC(Viewport);
#endif
RB_METHOD(viewportInitialize)
{
Viewport *v;
RB_METHOD(viewportInitialize) {
Viewport *v;
if (argc == 0 && rgssVer >= 3)
{
v = new Viewport();
}
else if (argc == 1)
{
/* The rect arg is only used to init the viewport,
* and does NOT replace its 'rect' property */
VALUE rectObj;
Rect *rect;
if (argc == 0 && rgssVer >= 3) {
v = new Viewport();
} else if (argc == 1) {
/* The rect arg is only used to init the viewport,
* and does NOT replace its 'rect' property */
VALUE rectObj;
Rect *rect;
rb_get_args(argc, argv, "o", &rectObj RB_ARG_END);
rb_get_args(argc, argv, "o", &rectObj RB_ARG_END);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
rect = getPrivateDataCheck<Rect>(rectObj, RectType);
v = new Viewport(rect);
}
else
{
int x, y, width, height;
v = new Viewport(rect);
} else {
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);
v = new Viewport(x, y, width, height);
}
v = new Viewport(x, y, width, height);
}
setPrivateData(self, v);
setPrivateData(self, v);
/* Wrap property objects */
v->initDynAttribs();
/* Wrap property objects */
v->initDynAttribs();
wrapProperty(self, &v->getRect(), "rect", RectType);
wrapProperty(self, &v->getColor(), "color", ColorType);
wrapProperty(self, &v->getTone(), "tone", ToneType);
wrapProperty(self, &v->getRect(), "rect", RectType);
wrapProperty(self, &v->getColor(), "color", ColorType);
wrapProperty(self, &v->getTone(), "tone", ToneType);
/* 'elements' holds all SceneElements that become children
* of this viewport, so we can dispose them when the viewport
* is disposed */
rb_iv_set(self, "elements", rb_ary_new());
/* 'elements' holds all SceneElements that become children
* of this viewport, so we can dispose them when the viewport
* is disposed */
rb_iv_set(self, "elements", rb_ary_new());
return self;
return self;
}
DEF_PROP_OBJ_VAL(Viewport, Rect, Rect, "rect")
DEF_PROP_OBJ_VAL(Viewport, Rect, Rect, "rect")
DEF_PROP_OBJ_VAL(Viewport, Color, Color, "color")
DEF_PROP_OBJ_VAL(Viewport, Tone, Tone, "tone")
DEF_PROP_OBJ_VAL(Viewport, Tone, Tone, "tone")
DEF_PROP_I(Viewport, OX)
DEF_PROP_I(Viewport, OY)
void
viewportBindingInit()
{
VALUE klass = rb_define_class("Viewport", rb_cObject);
#ifndef OLD_RUBY
rb_define_alloc_func(klass, classAllocate<&ViewportType>);
void viewportBindingInit() {
VALUE klass = rb_define_class("Viewport", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(klass, classAllocate<&ViewportType>);
#else
rb_define_alloc_func(klass, ViewportAllocate);
rb_define_alloc_func(klass, ViewportAllocate);
#endif
disposableBindingInit <Viewport>(klass);
flashableBindingInit <Viewport>(klass);
sceneElementBindingInit<Viewport>(klass);
disposableBindingInit<Viewport>(klass);
flashableBindingInit<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, OX, "ox" );
INIT_PROP_BIND( Viewport, OY, "oy" );
INIT_PROP_BIND( Viewport, Color, "color" );
INIT_PROP_BIND( Viewport, Tone, "tone" );
INIT_PROP_BIND(Viewport, Rect, "rect");
INIT_PROP_BIND(Viewport, OX, "ox");
INIT_PROP_BIND(Viewport, OY, "oy");
INIT_PROP_BIND(Viewport, Color, "color");
INIT_PROP_BIND(Viewport, Tone, "tone");
}

86
binding/window-binding.cpp
View file

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

165
binding/windowvx-binding.cpp
View file

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