void mrgss_renderer_draw(mrb_state* mrb, mrb_value window) {
mrb_value drawables;
mrb_bool sprite_visible;
mrgss_screen *swindow = DATA_PTR(window);
mrgss_renderer *renderer = swindow->renderer;
drawables = mrgss_iv_get(mrb, window, "drawables");
mrgss_renderer_wait_for_gl_lock();
mrgss_renderer_update_sprites_order(mrb, drawables, renderer);
//mrgss_renderer_sync_sprite_changes(mrb, drawables, renderer);
for(int i = 0; i < RARRAY_LEN(drawables); i++){
mrb_value rsprite = mrb_ary_entry(drawables, i);
mrgss_sprite *sprite = DATA_PTR(rsprite);
sprite_visible = mrb_bool(mrgss_iv_get(mrb, rsprite, "@visible"));
if(!sprite_visible || sprite->opacity <= 0) {
continue;
}
if(sprite->dirty) {
build_sprite_transforms_matrix(mrb, rsprite);
memcpy(&(renderer->persistentShaderBuffer[i * 16]), sprite->transforms.mat, sizeof(GLfloat) * 16);
sprite->dirty = 0;
}
if(sprite->newPos) {
update_sprite_position(mrb, rsprite);
memcpy(&(renderer->persistentBuffer[i * 4]), sprite->vertices, sizeof(sprite->vertices));
sprite->newPos = 0;
}
}
glUniform1f(glGetUniformLocation(renderer->shader, "opacity"), 1.0);
//glDrawArraysInstanced(GL_QUADS, 0, RARRAY_LEN(drawables) * 4, RARRAY_LEN(drawables) );
glDrawArrays(GL_QUADS, 0, RARRAY_LEN(drawables) * 4);
mrgss_renderer_lock_gl_buffer();
}
mrb_value mrb_serialport_open(mrb_state *mrb, mrb_value self) {
int fd;
mrb_value mrb_portname = IV_GET("@port_name");
mrb_value mrb_baud = IV_GET("@baud");
mrb_value mrb_blocking = IV_GET("@blocking");
const char *portname = mrb_string_value_cstr(mrb, &mrb_portname);
unsigned int baud = mrb_fixnum(mrb_baud);
fd = open(portname, O_RDWR | O_NOCTTY | O_SYNC);
if (fd < 0) {
update_error(mrb, self);
mrb_raise(mrb, E_RUNTIME_ERROR, strerror(errno));
}
if (!isatty(fd)) {
update_error(mrb, self);
mrb_raise(mrb, E_RUNTIME_ERROR, strerror(errno));
}
if (set_interface_attribs(fd, baud, 0)) {
update_error(mrb, self);
mrb_raise(mrb, E_RUNTIME_ERROR, strerror(errno));
}
if (set_blocking(fd, mrb_bool(mrb_blocking) ? 1 : 0) != 0) {
IV_SET("@error", mrb_str_new_cstr(mrb, "Could not set blocking behavior"));
mrb_raise(mrb, E_RUNTIME_ERROR, "Could not set blocking behavior");
}
IV_SET("@fd", mrb_fixnum_value(fd));
return self;
}
Ref* to_ref_value(mrb_state* mrb, mrb_value val)
{
switch (val.tt) {
case mrb_vtype::MRB_TT_FIXNUM:
{
mrb_int v = mrb_fixnum(val);
return Integer::create((int)v);
}
case mrb_vtype::MRB_TT_FLOAT:
{
mrb_float v = mrb_float(val);
return Double::create((double)v);
}
case mrb_vtype::MRB_TT_FALSE:
case mrb_vtype::MRB_TT_TRUE:
{
return Bool::create(mrb_bool(val));
}
case mrb_vtype::MRB_TT_STRING:
{
char* str = mrb_str_to_cstr(mrb, val);
return String::createWithFormat("%s", str);
}
case mrb_vtype::MRB_TT_SYMBOL:
{
mrb_sym sym = mrb_symbol(val);
const char* str = mrb_sym2name(mrb, sym);
return String::createWithFormat("%s", str);
}
case mrb_vtype::MRB_TT_RANGE:
{
// TODO: range
/*
mrb_int beg;
mrb_int len;
mrb_range_beg_len(mrb, val, &beg, &len, 0);
*/
break;
}
case mrb_vtype::MRB_TT_OBJECT:
{
// TODO: ruby object
break;
}
case mrb_vtype::MRB_TT_DATA:
{
Ref* ref =static_cast<Ref*>(mrb_get_datatype(mrb, val, &ruby_cocos2dx_Ref_type));
return ref;
}
case mrb_vtype::MRB_TT_UNDEF:
break;
default:
CCASSERT(false, "not supported type");
}
return nullptr;
}
mrb_value
mrb_range_eq(mrb_state *mrb, mrb_value range)
{
struct RRange *rr;
struct RRange *ro;
mrb_value obj;
mrb_get_args(mrb, "o", &obj);
if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value();
if (!mrb_obj_is_instance_of(mrb, obj, mrb_obj_class(mrb, range))) { /* same class? */
return mrb_false_value();
}
rr = mrb_range_ptr(range);
ro = mrb_range_ptr(obj);
if (!mrb_bool(mrb_funcall(mrb, rr->edges->beg, "==", 1, ro->edges->beg)) ||
!mrb_bool(mrb_funcall(mrb, rr->edges->end, "==", 1, ro->edges->end)) ||
rr->excl != ro->excl) {
return mrb_false_value();
}
return mrb_true_value();
}
mrb_value
mrb_f_syslog_close(mrb_state *mrb, mrb_value self)
{
mrb_value opened;
opened = mrb_cv_get(mrb, self, mrb_intern_lit(mrb, "@opened"));
if (! mrb_bool(opened)) {
mrb_raise(mrb, E_RUNTIME_ERROR, "syslog not opened");
}
closelog();
reset_vars(mrb, self);
return mrb_nil_value();
}
mrb_value
mrb_f_syslog_open(mrb_state *mrb, mrb_value self)
{
mrb_value ident, opened;
mrb_int facility, options;
opened = mrb_cv_get(mrb, self, mrb_intern_lit(mrb, "@opened"));
if (mrb_bool(opened)) {
mrb_raise(mrb, E_RUNTIME_ERROR, "syslog already open");
}
ident = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$0"));
options = LOG_PID | LOG_CONS;
facility = LOG_USER;
mrb_get_args(mrb, "|Sii", &ident, &options, &facility);
ident = mrb_check_string_type(mrb, ident);
/*
* We assume mrb_str_new() returns a *not-shared* string with a NUL
* character at the end of the string.
*/
ident = mrb_str_new(mrb, RSTRING_PTR(ident), RSTRING_LEN(ident));
/*
* We must set "ident" to a class variable before calling openlog(3).
* Otherwise, syslog(3) may refer to some unallocated (GC'ed out) memory
* area when mrb_cv_set() fails. Note that some openlog(3) implementations
* store "ident" argument as is (not strdup(3)ed!).
* http://man7.org/linux/man-pages/man3/syslog.3.html#NOTES
*
* And we make class variable "ident" inaccessible from Ruby world
* for safety.
*/
mrb_cv_set(mrb, self, mrb_intern_lit(mrb, "ident"), ident);
openlog(RSTRING_PTR(ident), options, facility);
mrb_cv_set(mrb, self, mrb_intern_lit(mrb, "@opened"), mrb_true_value());
mrb_cv_set(mrb, self, mrb_intern_lit(mrb, "@options"), mrb_fixnum_value(options));
mrb_cv_set(mrb, self, mrb_intern_lit(mrb, "@facility"), mrb_fixnum_value(facility));
return self;
}
/*
* call-seq:
* obj.respond_to?(symbol, include_private=false) -> true or false
*
* Returns +true+ if _obj_ responds to the given
* method. Private methods are included in the search only if the
* optional second parameter evaluates to +true+.
*
* If the method is not implemented,
* as Process.fork on Windows, File.lchmod on GNU/Linux, etc.,
* false is returned.
*
* If the method is not defined, <code>respond_to_missing?</code>
* method is called and the result is returned.
*/
static mrb_value
obj_respond_to(mrb_state *mrb, mrb_value self)
{
mrb_sym id, rtm_id;
mrb_bool priv = FALSE, respond_to_p;
mrb_get_args(mrb, "n|b", &id, &priv);
respond_to_p = basic_obj_respond_to(mrb, self, id, !priv);
if (!respond_to_p) {
rtm_id = mrb_intern_lit(mrb, "respond_to_missing?");
if (basic_obj_respond_to(mrb, self, rtm_id, !priv)) {
mrb_value args[2], v;
args[0] = mrb_symbol_value(id);
args[1] = mrb_bool_value(priv);
v = mrb_funcall_argv(mrb, self, rtm_id, 2, args);
return mrb_bool_value(mrb_bool(v));
}
}
return mrb_bool_value(respond_to_p);
}
bool rubyval_to_ccvalue(mrb_state* mrb, mrb_value arg, cocos2d::Value* ret, const char* funcName)
{
switch (arg.tt) {
case mrb_vtype::MRB_TT_ARRAY:
{
ValueVector arrVal;
if (! rubyval_to_ccvaluevector(mrb, arg, &arrVal)) {
return false;
}
*ret = Value(arrVal);
break;
}
case mrb_vtype::MRB_TT_HASH:
{
ValueMap dictVal;
if (! rubyval_to_ccvaluemap(mrb, arg, &dictVal)) {
return false;
}
*ret = Value(dictVal);
break;
}
case mrb_vtype::MRB_TT_RANGE:
{
// TODO
return false;
break;
}
case mrb_vtype::MRB_TT_FIXNUM:
{
mrb_int val = mrb_fixnum(arg);
*ret = Value((int)val);
break;
}
case mrb_vtype::MRB_TT_FLOAT:
{
mrb_float val = mrb_float(arg);
*ret = Value((float)val);
break;
}
case mrb_vtype::MRB_TT_TRUE:
case mrb_vtype::MRB_TT_FALSE:
{
bool val = mrb_bool(arg);
*ret = Value(val);
break;
}
case mrb_vtype::MRB_TT_STRING:
{
char* val = mrb_str_to_cstr(mrb, arg);
*ret = Value(val);
break;
}
case mrb_vtype::MRB_TT_SYMBOL:
{
mrb_sym sym = mrb_symbol(arg);
const char* val = mrb_sym2name(mrb, sym);
*ret = Value(val);
break;
}
default:
return false;
}
return true;
}
static mrb_value ngx_mrb_add_listener(mrb_state *mrb, mrb_value self)
{
// ref: http/ngx_http_core_module.c ngx_http_core_listen
ngx_http_mruby_srv_conf_t *mscf = mrb->ud;
ngx_http_core_srv_conf_t *cscf = mscf->cscf;
ngx_conf_t *cf = mscf->cf;
ngx_str_t addr;
ngx_url_t u;
ngx_http_listen_opt_t lsopt;
mrb_value listener, address;
mrb_get_args(mrb, "H", &listener);
address = mrb_hash_get(mrb, listener, mrb_check_intern_cstr(mrb, "address"));
addr.data = (u_char *)RSTRING_PTR(address);
addr.len = RSTRING_LEN(address);
ngx_memzero(&u, sizeof(ngx_url_t));
u.url = addr;
u.listen = 1;
u.default_port = 80;
cscf->listen = 1;
if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
if (u.err) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%s in \"%V\" of the \"listen\" directive via mruby", u.err, &u.url);
}
mrb_raise(mrb, E_RUNTIME_ERROR, "ngx_mrb_add_listener ngx_parse_url failed");
}
ngx_memzero(&lsopt, sizeof(ngx_http_listen_opt_t));
ngx_memcpy(&lsopt.sockaddr.sockaddr, &u.sockaddr, u.socklen);
lsopt.socklen = u.socklen;
lsopt.backlog = NGX_LISTEN_BACKLOG;
lsopt.rcvbuf = -1;
lsopt.sndbuf = -1;
#if (NGX_HAVE_SETFIB)
lsopt.setfib = -1;
#endif
#if (NGX_HAVE_TCP_FASTOPEN)
lsopt.fastopen = -1;
#endif
lsopt.wildcard = u.wildcard;
#if (NGX_HAVE_INET6)
lsopt.ipv6only = 1;
#endif
if (mrb_bool(mrb_hash_get(mrb, listener, mrb_check_intern_cstr(mrb, "ssl")))) {
#if (NGX_HTTP_SSL)
lsopt.ssl = 1;
#else
mrb_raise(mrb, E_RUNTIME_ERROR, "the ssl symbol requires ngx_http_ssl_module");
#endif
}
if (mrb_bool(mrb_hash_get(mrb, listener, mrb_check_intern_cstr(mrb, "http2")))) {
#if (NGX_HTTP_V2)
lsopt.http2 = 1;
#else
mrb_raise(mrb, E_RUNTIME_ERROR, "the http2 symbol requires ngx_http_http2_module");
#endif
}
(void)ngx_sock_ntop(&lsopt.sockaddr.sockaddr, lsopt.socklen, lsopt.addr, NGX_SOCKADDR_STRLEN, 1);
if (ngx_http_add_listen(cf, cscf, &lsopt) == NGX_OK) {
ngx_conf_log_error(NGX_LOG_INFO, cf, 0, "add listener %V via mruby", &addr);
return mrb_true_value();
}
mrb_raise(mrb, E_RUNTIME_ERROR, "ngx_mrb_add_listener ngx_http_add_listen failed");
}
