327 lines
10 KiB
C++
327 lines
10 KiB
C++
#include "app/app.h"
|
|
#include "bindings/definitions.h"
|
|
|
|
namespace {
|
|
void ElementImage_free(mrb_state *mrb, void *ptr) {
|
|
UNUSED(mrb);
|
|
uint64_t id = ((Wrapper *)ptr)->id;
|
|
app::element_pool.release(id);
|
|
delete (Wrapper *)ptr;
|
|
}
|
|
|
|
const struct mrb_data_type ElementImage_type = {
|
|
"ElementImage",
|
|
ElementImage_free
|
|
};
|
|
|
|
mrb_value ElementImage_init(mrb_state *mrb, mrb_value self) {
|
|
Wrapper *old = (Wrapper *)DATA_PTR(self);
|
|
if (old)
|
|
mrb_free(mrb, old);
|
|
mrb_data_init(self, nullptr, &ElementImage_type);
|
|
Wrapper *s = new Wrapper();
|
|
|
|
mrb_value animation_val;
|
|
mrb_value kwargs;
|
|
mrb_get_args(mrb, "o|H", &animation_val, &kwargs);
|
|
if (!mrb_obj_is_kind_of(
|
|
mrb,
|
|
animation_val,
|
|
definitions::bindings.Animation.cls
|
|
)) {
|
|
mrb_raise(
|
|
mrb,
|
|
mrb_class_get(mrb, "Exception"),
|
|
"Expected an Animation object"
|
|
);
|
|
return mrb_nil_value();
|
|
}
|
|
|
|
float x = 0, y = 0, z = 0, rotation = 0;
|
|
float scale_x = 1, scale_y = 1, alpha = 1, pivot_x = 0.5, pivot_y = 0.5;
|
|
mrb_sym click_mode_sym = sym_block;
|
|
if (!mrb_nil_p(kwargs)) {
|
|
mrb_value pos_hash = HASH_GET(kwargs, position);
|
|
if (!mrb_nil_p(pos_hash)) {
|
|
HASH_FLOAT(pos_hash, x, x);
|
|
HASH_FLOAT(pos_hash, y, y);
|
|
}
|
|
|
|
mrb_value scale_hash = HASH_GET(kwargs, scale);
|
|
if (!mrb_nil_p(scale_hash)) {
|
|
HASH_FLOAT(scale_hash, x, scale_x);
|
|
HASH_FLOAT(scale_hash, y, scale_y);
|
|
}
|
|
|
|
mrb_value pivot_hash = HASH_GET(kwargs, pivot);
|
|
if (!mrb_nil_p(pivot_hash)) {
|
|
HASH_FLOAT(pivot_hash, x, pivot_x);
|
|
HASH_FLOAT(pivot_hash, y, pivot_y);
|
|
}
|
|
|
|
HASH_FLOAT(kwargs, z, z);
|
|
HASH_FLOAT(kwargs, rotation, rotation);
|
|
HASH_FLOAT(kwargs, alpha, alpha);
|
|
mrb_value v = HASH_GET(kwargs, click_mode);
|
|
if (!mrb_nil_p(v)) {
|
|
click_mode_sym = mrb_symbol(v);
|
|
}
|
|
}
|
|
|
|
Wrapper *animation_wrapper = (Wrapper *)DATA_PTR(animation_val);
|
|
uint64_t id = animation_wrapper->id;
|
|
animation_pool.use(id);
|
|
|
|
app::EImage *element = new app::EImage(id);
|
|
element->position = {x, y};
|
|
element->scale = {scale_x, scale_y};
|
|
element->rotation = rotation;
|
|
element->pivot = {pivot_x, pivot_y};
|
|
element->alpha = alpha;
|
|
element->z = z;
|
|
|
|
std::string click_mode = mrb_sym2name(mrb, click_mode_sym);
|
|
|
|
if (click_mode == "pass")
|
|
element->click_mode = ClickMode::PASS;
|
|
else if (click_mode == "block")
|
|
element->click_mode = ClickMode::BLOCK;
|
|
else if (click_mode == "ignore")
|
|
element->click_mode = ClickMode::IGNORE;
|
|
|
|
s->id = app::element_pool.acquire(element);
|
|
app::element_pool.use(s->id);
|
|
|
|
mrb_data_init(self, s, &ElementImage_type);
|
|
return self;
|
|
}
|
|
|
|
mrb_value element_image_on_click(mrb_state *mrb, mrb_value self) {
|
|
mrb_value block;
|
|
mrb_get_args(mrb, "&", &block);
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::Element *element = app::element_pool[id];
|
|
element->on_click.set_proc(block);
|
|
return self;
|
|
}
|
|
|
|
mrb_value element_image_equal(mrb_state *mrb, mrb_value self) {
|
|
mrb_value other;
|
|
mrb_get_args(mrb, "o", &other);
|
|
|
|
if (!mrb_obj_is_kind_of(mrb, other, definitions::bindings.ElementImage.cls))
|
|
return mrb_false_value();
|
|
|
|
Wrapper *wrapper_self = (Wrapper *)DATA_PTR(self);
|
|
Wrapper *wrapper_other = (Wrapper *)DATA_PTR(other);
|
|
return mrb_bool_value(wrapper_self->id == wrapper_other->id);
|
|
}
|
|
|
|
mrb_value element_image_inspect(mrb_state *mrb, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
std::string str = "#<ElementImage:0x"
|
|
+ std::format("0x{:016x}", id)
|
|
+ " animation_id=0x"
|
|
+ std::format("{:016x}", element->animation_id)
|
|
+ ">";
|
|
return mrb_str_new_cstr(mrb, str.c_str());
|
|
}
|
|
|
|
mrb_value element_image_hash(mrb_state *, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
return mrb_fixnum_value(wrapper->id);
|
|
}
|
|
|
|
mrb_value element_image_animation_set(mrb_state *mrb, mrb_value self) {
|
|
mrb_value animation;
|
|
mrb_get_args(mrb, "o", &animation);
|
|
|
|
if (!mrb_obj_is_kind_of(
|
|
mrb,
|
|
animation,
|
|
definitions::bindings.Animation.cls
|
|
)) {
|
|
mrb_raise(
|
|
mrb,
|
|
mrb_class_get(mrb, "Exception"),
|
|
"Expected an Animation object"
|
|
);
|
|
return mrb_nil_value();
|
|
}
|
|
|
|
Wrapper *animation_wrapper = (Wrapper *)DATA_PTR(animation);
|
|
uint64_t animation_id = animation_wrapper->id;
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
|
|
animation_pool.use(animation_id);
|
|
animation_pool.release(element->animation_id);
|
|
|
|
element->animation_id = animation_id;
|
|
|
|
return self;
|
|
}
|
|
|
|
mrb_value element_image_animation_get(mrb_state *, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
uint64_t animation_id = element->animation_id;
|
|
if (animation_id == UINT64_MAX)
|
|
return mrb_nil_value();
|
|
animation_pool.use(animation_id);
|
|
return definitions::wrap(definitions::bindings.Animation, animation_id);
|
|
}
|
|
|
|
mrb_value element_image_position_get(mrb_state *, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
return definitions::Vec2_wrap(id, &element->position);
|
|
}
|
|
|
|
mrb_value element_image_rotation_get(mrb_state *mrb, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
return mrb_float_value(mrb, element->rotation);
|
|
}
|
|
|
|
mrb_value element_image_rotation_set(mrb_state *mrb, mrb_value self) {
|
|
mrb_float rotation;
|
|
mrb_get_args(mrb, "f", &rotation);
|
|
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
element->rotation = rotation;
|
|
|
|
return mrb_nil_value();
|
|
}
|
|
|
|
mrb_value element_image_pivot_get(mrb_state *, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
return definitions::Vec2_wrap(id, &element->pivot);
|
|
}
|
|
|
|
mrb_value element_image_scale_get(mrb_state *, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
return definitions::Vec2_wrap(id, &element->scale);
|
|
}
|
|
|
|
mrb_value element_image_alpha_get(mrb_state *mrb, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
return mrb_float_value(mrb, element->alpha);
|
|
}
|
|
|
|
mrb_value element_image_alpha_set(mrb_state *mrb, mrb_value self) {
|
|
mrb_float alpha;
|
|
mrb_get_args(mrb, "f", &alpha);
|
|
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
element->alpha = alpha;
|
|
|
|
return mrb_nil_value();
|
|
}
|
|
|
|
mrb_value element_image_z_get(mrb_state *mrb, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
return mrb_float_value(mrb, element->z);
|
|
}
|
|
|
|
mrb_value element_image_z_set(mrb_state *mrb, mrb_value self) {
|
|
mrb_float z;
|
|
mrb_get_args(mrb, "f", &z);
|
|
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
element->z = z;
|
|
|
|
return mrb_nil_value();
|
|
}
|
|
|
|
mrb_value element_image_click_mode_get(mrb_state *mrb, mrb_value self) {
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
|
|
std::string click_mode_str;
|
|
switch (element->click_mode) {
|
|
case ClickMode::PASS:
|
|
click_mode_str = "pass";
|
|
break;
|
|
case ClickMode::BLOCK:
|
|
click_mode_str = "block";
|
|
break;
|
|
case ClickMode::IGNORE:
|
|
click_mode_str = "ignore";
|
|
break;
|
|
}
|
|
|
|
return mrb_symbol_value(mrb_intern_cstr(mrb, click_mode_str.c_str()));
|
|
}
|
|
|
|
mrb_value element_image_click_mode_set(mrb_state *mrb, mrb_value self) {
|
|
mrb_sym click_mode_sym;
|
|
mrb_get_args(mrb, "n", &click_mode_sym);
|
|
|
|
Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
|
|
uint64_t id = wrapper->id;
|
|
app::EImage *element = (app::EImage *)app::element_pool[id];
|
|
|
|
std::string click_mode = mrb_sym2name(mrb, click_mode_sym);
|
|
|
|
if (click_mode == "pass")
|
|
element->click_mode = ClickMode::PASS;
|
|
else if (click_mode == "block")
|
|
element->click_mode = ClickMode::BLOCK;
|
|
else if (click_mode == "ignore")
|
|
element->click_mode = ClickMode::IGNORE;
|
|
|
|
return mrb_nil_value();
|
|
}
|
|
} // namespace
|
|
|
|
namespace definitions {
|
|
void register_element_image() {
|
|
DEF_CLASS(ElementImage, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
|
|
ADD_METHOD(ElementImage, "click", element_image_on_click, MRB_ARGS_BLOCK());
|
|
ADD_METHOD(ElementImage, "==", element_image_equal, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "eql?", element_image_equal, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "inspect", element_image_inspect, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "to_s", element_image_inspect, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "hash", element_image_hash, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "animation=", element_image_animation_set, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "animation", element_image_animation_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "position", element_image_position_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "scale", element_image_scale_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "rotation=", element_image_rotation_set, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "rotation", element_image_rotation_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "pivot", element_image_pivot_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "alpha=", element_image_alpha_set, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "alpha", element_image_alpha_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "z=", element_image_z_set, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "z", element_image_z_get, MRB_ARGS_NONE());
|
|
ADD_METHOD(ElementImage, "click_mode=", element_image_click_mode_set, MRB_ARGS_REQ(1));
|
|
ADD_METHOD(ElementImage, "click_mode", element_image_click_mode_get, MRB_ARGS_NONE());
|
|
|
|
bindings.ElementImage = {ElementImage_class, &ElementImage_type};
|
|
}
|
|
} // namespace definitions
|