From acc977a5bc75f63d218b0e990ccd5de448cc1922 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 15 Jul 2016 00:26:19 +0900 Subject: [PATCH] ls modules/**/*.[hc]xx | xargs clang-format -i -style="{PointerAlignment: Left, BasedOnStyle: Mozilla}" --- .../include/moon/gorilla/audio.hxx | 26 +- .../include/moon/gorilla/mrb/music.hxx | 4 +- .../include/moon/gorilla/mrb/sound.hxx | 4 +- .../include/moon/gorilla/music.hxx | 13 +- modules/audio-gorilla/src/audio.cxx | 78 ++-- modules/audio-gorilla/src/mrb_moon_audio.cxx | 14 +- modules/audio-gorilla/src/mrb_music.cxx | 101 +++-- modules/audio-gorilla/src/mrb_sound.cxx | 43 +- modules/audio-portaudio/src/audio.cxx | 25 +- modules/graphics/include/moon/font.hxx | 33 +- modules/graphics/include/moon/graphics.hxx | 22 +- modules/graphics/include/moon/mrb/font.hxx | 8 +- modules/graphics/include/moon/mrb/shader.hxx | 11 +- modules/graphics/include/moon/mrb/texture.hxx | 25 +- .../include/moon/mrb/vertex_buffer.hxx | 11 +- modules/graphics/include/moon/shader.hxx | 68 +-- modules/graphics/include/moon/texture.hxx | 34 +- .../graphics/include/moon/vertex_buffer.hxx | 66 +-- modules/graphics/src/font.cxx | 235 +++++----- modules/graphics/src/mrb_font.cxx | 73 +-- modules/graphics/src/mrb_graphics.cxx | 14 +- modules/graphics/src/mrb_shader.cxx | 80 ++-- modules/graphics/src/mrb_sprite.cxx | 60 +-- modules/graphics/src/mrb_spritesheet.cxx | 112 ++--- modules/graphics/src/mrb_text.cxx | 43 +- modules/graphics/src/mrb_texture.cxx | 52 +-- modules/graphics/src/mrb_vertex_buffer.cxx | 102 +++-- modules/graphics/src/shader.cxx | 334 ++++++++------ modules/graphics/src/texture.cxx | 96 ++-- modules/graphics/src/vertex_buffer.cxx | 299 ++++++------ modules/system/include/moon/fps.hxx | 30 +- modules/system/include/moon/matrix4.hxx | 2 +- modules/system/include/moon/mrb/clock.hxx | 8 +- modules/system/include/moon/mrb/context.hxx | 4 +- modules/system/include/moon/mrb/helpers.hxx | 14 +- modules/system/include/moon/mrb/matrix4.hxx | 19 +- modules/system/include/moon/mrb/rect.hxx | 21 +- modules/system/include/moon/mrb/vector1.hxx | 21 +- modules/system/include/moon/mrb/vector2.hxx | 19 +- modules/system/include/moon/mrb/vector3.hxx | 19 +- modules/system/include/moon/mrb/vector4.hxx | 19 +- .../system/include/moon/mrb/vector_unroll.hxx | 68 +-- modules/system/include/moon/mrb_err.hxx | 5 +- modules/system/include/moon/rect.hxx | 38 +- modules/system/include/moon/string.hxx | 153 +++---- modules/system/include/moon/vector1.hxx | 4 +- modules/system/include/moon/vector2.hxx | 2 +- modules/system/include/moon/vector3.hxx | 2 +- modules/system/include/moon/vector4.hxx | 2 +- modules/system/src/fps.cxx | 67 +-- modules/system/src/mrb_clock.cxx | 50 ++- modules/system/src/mrb_context.cxx | 37 +- modules/system/src/mrb_err.cxx | 13 +- modules/system/src/mrb_matrix4.cxx | 425 +++++++++--------- modules/system/src/mrb_rect.cxx | 126 +++--- modules/system/src/mrb_system.cxx | 12 +- modules/system/src/mrb_vector1.cxx | 272 ++++++----- modules/system/src/mrb_vector2.cxx | 227 +++++----- modules/system/src/mrb_vector3.cxx | 296 ++++++------ modules/system/src/mrb_vector4.cxx | 241 +++++----- 60 files changed, 2315 insertions(+), 1987 deletions(-) diff --git a/modules/audio-gorilla/include/moon/gorilla/audio.hxx b/modules/audio-gorilla/include/moon/gorilla/audio.hxx index 0215b19..f370dc8 100644 --- a/modules/audio-gorilla/include/moon/gorilla/audio.hxx +++ b/modules/audio-gorilla/include/moon/gorilla/audio.hxx @@ -6,18 +6,20 @@ #include namespace Moon { - class Audio { - public: - static bool Initialize(); - static void Update(); - static void Terminate(); - static ga_Mixer* GetMixer(); - static ga_StreamManager* GetStreamMgr(); - protected: - static gau_Manager* m_mgr; - static ga_Mixer* m_mixer; - static ga_StreamManager* m_streamMgr; - }; +class Audio +{ +public: + static bool Initialize(); + static void Update(); + static void Terminate(); + static ga_Mixer* GetMixer(); + static ga_StreamManager* GetStreamMgr(); + +protected: + static gau_Manager* m_mgr; + static ga_Mixer* m_mixer; + static ga_StreamManager* m_streamMgr; +}; }; #endif diff --git a/modules/audio-gorilla/include/moon/gorilla/mrb/music.hxx b/modules/audio-gorilla/include/moon/gorilla/mrb/music.hxx index de86936..6cc0971 100644 --- a/modules/audio-gorilla/include/moon/gorilla/mrb/music.hxx +++ b/modules/audio-gorilla/include/moon/gorilla/mrb/music.hxx @@ -1,12 +1,12 @@ #ifndef MMRB_MUSIC_H #define MMRB_MUSIC_H +#include "moon/api.h" #include #include #include -#include "moon/api.h" MOON_C_API const struct mrb_data_type music_data_type; -MOON_C_API void mmrb_music_init(mrb_state *mrb); +MOON_C_API void mmrb_music_init(mrb_state* mrb); #endif diff --git a/modules/audio-gorilla/include/moon/gorilla/mrb/sound.hxx b/modules/audio-gorilla/include/moon/gorilla/mrb/sound.hxx index 359607e..9e02299 100644 --- a/modules/audio-gorilla/include/moon/gorilla/mrb/sound.hxx +++ b/modules/audio-gorilla/include/moon/gorilla/mrb/sound.hxx @@ -1,12 +1,12 @@ #ifndef MMRB_SOUND_H #define MMRB_SOUND_H +#include "moon/api.h" #include #include #include -#include "moon/api.h" MOON_C_API const struct mrb_data_type sound_data_type; -MOON_C_API void mmrb_sound_init(mrb_state *mrb); +MOON_C_API void mmrb_sound_init(mrb_state* mrb); #endif diff --git a/modules/audio-gorilla/include/moon/gorilla/music.hxx b/modules/audio-gorilla/include/moon/gorilla/music.hxx index 8e97307..f8ec24e 100644 --- a/modules/audio-gorilla/include/moon/gorilla/music.hxx +++ b/modules/audio-gorilla/include/moon/gorilla/music.hxx @@ -4,11 +4,14 @@ #include "moon/gorilla/audio.hxx" namespace Moon { - struct Music { - Music() : handle(NULL), loopSrc(NULL) { }; - ga_Handle* handle; - gau_SampleSourceLoop* loopSrc; - }; +struct Music +{ + Music() + : handle(NULL) + , loopSrc(NULL){}; + ga_Handle* handle; + gau_SampleSourceLoop* loopSrc; +}; }; #endif diff --git a/modules/audio-gorilla/src/audio.cxx b/modules/audio-gorilla/src/audio.cxx index 3871200..3d4ec43 100644 --- a/modules/audio-gorilla/src/audio.cxx +++ b/modules/audio-gorilla/src/audio.cxx @@ -1,44 +1,54 @@ #include "moon/gorilla/audio.hxx" namespace Moon { - gau_Manager* Audio::m_mgr = NULL; - ga_Mixer* Audio::m_mixer = NULL; - ga_StreamManager* Audio::m_streamMgr = NULL; +gau_Manager* Audio::m_mgr = NULL; +ga_Mixer* Audio::m_mixer = NULL; +ga_StreamManager* Audio::m_streamMgr = NULL; - bool Audio::Initialize() { - // setup Gorilla Audio - if (!m_mgr) { - if (gc_initialize(0) == GC_SUCCESS) { - m_mgr = gau_manager_create(); - m_mixer = gau_manager_mixer(m_mgr); - m_streamMgr = gau_manager_streamManager(m_mgr); - } else { - return false; - } +bool +Audio::Initialize() +{ + // setup Gorilla Audio + if (!m_mgr) { + if (gc_initialize(0) == GC_SUCCESS) { + m_mgr = gau_manager_create(); + m_mixer = gau_manager_mixer(m_mgr); + m_streamMgr = gau_manager_streamManager(m_mgr); + } else { + return false; } - return true; - }; + } + return true; +}; - void Audio::Update() { - if (m_mgr) gau_manager_update(m_mgr); - }; +void +Audio::Update() +{ + if (m_mgr) + gau_manager_update(m_mgr); +}; - void Audio::Terminate() { - if (m_mgr) { - gau_manager_destroy(m_mgr); - gc_shutdown(); - m_mgr = NULL; - m_mixer = NULL; - m_streamMgr = NULL; - } - }; +void +Audio::Terminate() +{ + if (m_mgr) { + gau_manager_destroy(m_mgr); + gc_shutdown(); + m_mgr = NULL; + m_mixer = NULL; + m_streamMgr = NULL; + } +}; - ga_Mixer* Audio::GetMixer() { - return m_mixer; - }; +ga_Mixer* +Audio::GetMixer() +{ + return m_mixer; +}; - ga_StreamManager* Audio::GetStreamMgr() { - return m_streamMgr; - }; +ga_StreamManager* +Audio::GetStreamMgr() +{ + return m_streamMgr; +}; } - diff --git a/modules/audio-gorilla/src/mrb_moon_audio.cxx b/modules/audio-gorilla/src/mrb_moon_audio.cxx index cd82a80..4ce61fe 100644 --- a/modules/audio-gorilla/src/mrb_moon_audio.cxx +++ b/modules/audio-gorilla/src/mrb_moon_audio.cxx @@ -1,13 +1,13 @@ -#include -#include #include "moon/gorilla/audio.hxx" #include "moon/gorilla/mrb/music.hxx" #include "moon/gorilla/mrb/sound.hxx" +#include +#include /* Call once per step/frame to update the internal Audio module. */ static mrb_value -audio_update(mrb_state *mrb, mrb_value klass) +audio_update(mrb_state* mrb, mrb_value klass) { Moon::Audio::Update(); return klass; @@ -16,9 +16,11 @@ audio_update(mrb_state *mrb, mrb_value klass) MOON_C_API void mrb_mruby_moon_audio_gorilla_gem_init(mrb_state* mrb) { - struct RClass *moon_module = mrb_define_module(mrb, "Moon"); - struct RClass *audio_module = mrb_define_module_under(mrb, moon_module, "Audio"); - mrb_define_class_method(mrb, audio_module, "update", audio_update, MRB_ARGS_NONE()); + struct RClass* moon_module = mrb_define_module(mrb, "Moon"); + struct RClass* audio_module = + mrb_define_module_under(mrb, moon_module, "Audio"); + mrb_define_class_method(mrb, audio_module, "update", audio_update, + MRB_ARGS_NONE()); mmrb_music_init(mrb); mmrb_sound_init(mrb); Moon::Audio::Initialize(); diff --git a/modules/audio-gorilla/src/mrb_music.cxx b/modules/audio-gorilla/src/mrb_music.cxx index 1cc01be..629ed8d 100644 --- a/modules/audio-gorilla/src/mrb_music.cxx +++ b/modules/audio-gorilla/src/mrb_music.cxx @@ -1,43 +1,43 @@ +#include "moon/api.h" +#include "moon/gorilla/mrb/music.hxx" +#include "moon/gorilla/music.hxx" +#include "moon/intern.h" #include #include #include #include -#include "moon/gorilla/mrb/music.hxx" -#include "moon/gorilla/music.hxx" -#include "moon/api.h" -#include "moon/intern.h" static void -music_free(mrb_state *mrb, void *p) +music_free(mrb_state* mrb, void* p) { Moon::Music* music = (Moon::Music*)p; if (music) { if (music->handle) { ga_handle_destroy(music->handle); } - delete(music); + delete (music); } } MOON_C_API const struct mrb_data_type music_data_type = { "Music", music_free }; static inline Moon::Music* -get_music(mrb_state *mrb, mrb_value self) +get_music(mrb_state* mrb, mrb_value self) { return (Moon::Music*)mrb_data_get_ptr(mrb, self, &music_data_type); } -/* +/* * @param [String] filename path to the music file * @param [String] format type of the file * @return [Music] */ static mrb_value -music_initialize(mrb_state *mrb, mrb_value self) +music_initialize(mrb_state* mrb, mrb_value self) { - char *filename; - char *format; - Moon::Music *music; + char* filename; + char* format; + Moon::Music* music; mrb_get_args(mrb, "zz", &filename, &format); @@ -48,11 +48,12 @@ music_initialize(mrb_state *mrb, mrb_value self) music = new Moon::Music(); if (exists(filename)) { - music->handle = gau_create_handle_buffered_file(Moon::Audio::GetMixer(), Moon::Audio::GetStreamMgr(), - filename, format, - NULL, 0, &(music->loopSrc)); + music->handle = gau_create_handle_buffered_file( + Moon::Audio::GetMixer(), Moon::Audio::GetStreamMgr(), filename, format, + NULL, 0, &(music->loopSrc)); } else { - mrb_raisef(mrb, E_SCRIPT_ERROR, "cannot load such file -- %S", mrb_str_new_cstr(mrb, filename)); + mrb_raisef(mrb, E_SCRIPT_ERROR, "cannot load such file -- %S", + mrb_str_new_cstr(mrb, filename)); } mrb_data_init(self, music, &music_data_type); @@ -68,12 +69,12 @@ music_initialize(mrb_state *mrb, mrb_value self) * @return [nil] */ static mrb_value -music_play(mrb_state *mrb, mrb_value self) +music_play(mrb_state* mrb, mrb_value self) { mrb_float gain = 1.0; mrb_float pitch = 1.0; mrb_float pan = 0.0; - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); mrb_get_args(mrb, "|fff", &gain, &pitch, &pan); ga_handle_setParamf(music->handle, GA_HANDLE_PARAM_GAIN, gain); ga_handle_setParamf(music->handle, GA_HANDLE_PARAM_PITCH, pitch); @@ -87,9 +88,9 @@ music_play(mrb_state *mrb, mrb_value self) * @return [nil] */ static mrb_value -music_stop(mrb_state *mrb, mrb_value self) +music_stop(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); ga_handle_stop(music->handle); return mrb_nil_value(); }; @@ -99,9 +100,9 @@ music_stop(mrb_state *mrb, mrb_value self) * @return [Boolean] Returns true if currently playing, else false. */ static mrb_value -music_is_playing(mrb_state *mrb, mrb_value self) +music_is_playing(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); return mrb_bool_value(ga_handle_playing(music->handle)); } @@ -110,9 +111,9 @@ music_is_playing(mrb_state *mrb, mrb_value self) * @return [Boolean] Returns true if currently stopped, else false. */ static mrb_value -music_is_stopped(mrb_state *mrb, mrb_value self) +music_is_stopped(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); return mrb_bool_value(ga_handle_stopped(music->handle)); } @@ -121,9 +122,9 @@ music_is_stopped(mrb_state *mrb, mrb_value self) * @return [Boolean] Returns true if the playback is finished, else false. */ static mrb_value -music_is_finished(mrb_state *mrb, mrb_value self) +music_is_finished(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); return mrb_bool_value(ga_handle_finished(music->handle)); } @@ -133,10 +134,10 @@ music_is_finished(mrb_state *mrb, mrb_value self) * @return [Boolean] Returns true if the seek was successful, else false. */ static mrb_value -music_seek(mrb_state *mrb, mrb_value self) +music_seek(mrb_state* mrb, mrb_value self) { mrb_int pos; - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); mrb_get_args(mrb, "i", &pos); return mrb_bool_value(ga_handle_seek(music->handle, pos)); } @@ -146,9 +147,9 @@ music_seek(mrb_state *mrb, mrb_value self) * @return [Integer] Current position in the file (in seconds). */ static mrb_value -music_pos(mrb_state *mrb, mrb_value self) +music_pos(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); return mrb_fixnum_value(ga_handle_tell(music->handle, GA_TELL_PARAM_CURRENT)); } @@ -157,9 +158,9 @@ music_pos(mrb_state *mrb, mrb_value self) * @return [Integer] Total length (in seconds). */ static mrb_value -music_length(mrb_state *mrb, mrb_value self) +music_length(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); return mrb_fixnum_value(ga_handle_tell(music->handle, GA_TELL_PARAM_TOTAL)); } @@ -170,11 +171,11 @@ music_length(mrb_state *mrb, mrb_value self) * @return [nil] */ static mrb_value -music_loop(mrb_state *mrb, mrb_value self) +music_loop(mrb_state* mrb, mrb_value self) { mrb_int trigger = -1; mrb_int target = 0; - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); mrb_get_args(mrb, "|ii", &trigger, &target); gau_sample_source_loop_set(music->loopSrc, trigger, target); return mrb_nil_value(); @@ -185,39 +186,45 @@ music_loop(mrb_state *mrb, mrb_value self) * @return [Boolean] true */ static mrb_value -music_clear_loop(mrb_state *mrb, mrb_value self) +music_clear_loop(mrb_state* mrb, mrb_value self) { - Moon::Music *music = get_music(mrb, self); + Moon::Music* music = get_music(mrb, self); gau_sample_source_loop_clear(music->loopSrc); return mrb_bool_value(true); } MOON_C_API void -mmrb_music_init(mrb_state *mrb) +mmrb_music_init(mrb_state* mrb) { struct RClass* mod = mrb_define_module(mrb, "Moon"); /* Music used to playing audio streams (usually background music). The file is * buffered from disk instead of streamed from memory, because songs can be * rather large in file size. */ - struct RClass *music_class = mrb_define_class_under(mrb, mod, "Music", mrb->object_class); + struct RClass* music_class = + mrb_define_class_under(mrb, mod, "Music", mrb->object_class); MRB_SET_INSTANCE_TT(music_class, MRB_TT_DATA); - mrb_define_method(mrb, music_class, "initialize", music_initialize, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, music_class, "initialize", music_initialize, + MRB_ARGS_REQ(2)); /* Playback */ mrb_define_method(mrb, music_class, "play", music_play, MRB_ARGS_OPT(3)); mrb_define_method(mrb, music_class, "stop", music_stop, MRB_ARGS_NONE()); /* Position */ - mrb_define_method(mrb, music_class, "seek", music_seek, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, music_class, "pos", music_pos, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "length", music_length, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "loop", music_loop, MRB_ARGS_OPT(2)); - mrb_define_method(mrb, music_class, "clear_loop", music_clear_loop, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "seek", music_seek, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, music_class, "pos", music_pos, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "length", music_length, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "loop", music_loop, MRB_ARGS_OPT(2)); + mrb_define_method(mrb, music_class, "clear_loop", music_clear_loop, + MRB_ARGS_NONE()); /* Query */ - mrb_define_method(mrb, music_class, "playing?", music_is_playing, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "stopped?", music_is_stopped, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "finished?", music_is_finished, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "playing?", music_is_playing, + MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "stopped?", music_is_stopped, + MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "finished?", music_is_finished, + MRB_ARGS_NONE()); } diff --git a/modules/audio-gorilla/src/mrb_sound.cxx b/modules/audio-gorilla/src/mrb_sound.cxx index e7e22de..96d454a 100644 --- a/modules/audio-gorilla/src/mrb_sound.cxx +++ b/modules/audio-gorilla/src/mrb_sound.cxx @@ -1,40 +1,40 @@ +#include "moon/api.h" +#include "moon/gorilla/audio.hxx" +#include "moon/gorilla/mrb/sound.hxx" +#include "moon/intern.h" #include #include #include #include -#include "moon/gorilla/mrb/sound.hxx" -#include "moon/gorilla/audio.hxx" -#include "moon/api.h" -#include "moon/intern.h" static void -sound_free(mrb_state *mrb, void *p) +sound_free(mrb_state* mrb, void* p) { - ga_Sound *sound = (ga_Sound*)p; + ga_Sound* sound = (ga_Sound*)p; if (sound) { - delete(sound); + delete (sound); } } MOON_C_API const struct mrb_data_type sound_data_type = { "Sound", sound_free }; static inline ga_Sound* -get_sound(mrb_state *mrb, mrb_value self) +get_sound(mrb_state* mrb, mrb_value self) { return (ga_Sound*)mrb_data_get_ptr(mrb, self, &sound_data_type); } -/* +/* * @param [String] filename path to the sound file * @param [String] format type of the file * @return [Sound] */ static mrb_value -sound_initialize(mrb_state *mrb, mrb_value self) +sound_initialize(mrb_state* mrb, mrb_value self) { char* filename; char* format; - ga_Sound *sound; + ga_Sound* sound; mrb_get_args(mrb, "zz", &filename, &format); @@ -47,7 +47,8 @@ sound_initialize(mrb_state *mrb, mrb_value self) if (exists(filename)) { sound = gau_load_sound_file(filename, format); } else { - mrb_raisef(mrb, E_SCRIPT_ERROR, "cannot load such file -- %S", mrb_str_new_cstr(mrb, filename)); + mrb_raisef(mrb, E_SCRIPT_ERROR, "cannot load such file -- %S", + mrb_str_new_cstr(mrb, filename)); } mrb_data_init(self, sound, &sound_data_type); @@ -63,15 +64,16 @@ sound_initialize(mrb_state *mrb, mrb_value self) * @return [nil] */ static mrb_value -sound_play(mrb_state *mrb, mrb_value self) +sound_play(mrb_state* mrb, mrb_value self) { mrb_float gain = 1.0; mrb_float pitch = 1.0; mrb_float pan = 0.0; - ga_Sound *sound = get_sound(mrb, self); + ga_Sound* sound = get_sound(mrb, self); ga_Handle* handle; mrb_get_args(mrb, "|fff", &gain, &pitch, &pan); - handle = gau_create_handle_sound(Moon::Audio::GetMixer(), sound, &gau_on_finish_destroy, 0, 0); + handle = gau_create_handle_sound(Moon::Audio::GetMixer(), sound, + &gau_on_finish_destroy, 0, 0); ga_handle_setParamf(handle, GA_HANDLE_PARAM_GAIN, gain); ga_handle_setParamf(handle, GA_HANDLE_PARAM_PITCH, pitch); ga_handle_setParamf(handle, GA_HANDLE_PARAM_PAN, pan); @@ -81,7 +83,7 @@ sound_play(mrb_state *mrb, mrb_value self) } MOON_C_API void -mmrb_sound_init(mrb_state *mrb) +mmrb_sound_init(mrb_state* mrb) { struct RClass* mod = mrb_define_module(mrb, "Moon"); /* Sounds are short audio files (usually used for sound effects) that are @@ -90,10 +92,11 @@ mmrb_sound_init(mrb_state *mrb) * * Use {Music} if you want to play longer audio/music streams. */ - struct RClass *sound_class = mrb_define_class_under(mrb, mod, "Sound", mrb->object_class); + struct RClass* sound_class = + mrb_define_class_under(mrb, mod, "Sound", mrb->object_class); MRB_SET_INSTANCE_TT(sound_class, MRB_TT_DATA); - mrb_define_method(mrb, sound_class, "initialize", sound_initialize, MRB_ARGS_REQ(2)); - mrb_define_method(mrb, sound_class, "play", sound_play, MRB_ARGS_OPT(3)); + mrb_define_method(mrb, sound_class, "initialize", sound_initialize, + MRB_ARGS_REQ(2)); + mrb_define_method(mrb, sound_class, "play", sound_play, MRB_ARGS_OPT(3)); } - diff --git a/modules/audio-portaudio/src/audio.cxx b/modules/audio-portaudio/src/audio.cxx index b34e020..f9c60ee 100644 --- a/modules/audio-portaudio/src/audio.cxx +++ b/modules/audio-portaudio/src/audio.cxx @@ -1,19 +1,18 @@ #include "moon/portaudio/audio.hxx" -namespace Moon +namespace Moon { +void +Audio::Initialize() { - void Audio::Initialize() - { - - } - - void Audio::Update() - { - - } +} - void Audio::Terminate() - { +void +Audio::Update() +{ +} - } +void +Audio::Terminate() +{ +} } diff --git a/modules/graphics/include/moon/font.hxx b/modules/graphics/include/moon/font.hxx index 900dbd9..2b98842 100644 --- a/modules/graphics/include/moon/font.hxx +++ b/modules/graphics/include/moon/font.hxx @@ -1,30 +1,33 @@ #ifndef MOON_FONT_H #define MOON_FONT_H -#include #include "moon/glm.h" #include "moon/intern.h" #include "moon/shader.hxx" -#include "moon/vertex_buffer.hxx" +#include "moon/string.hxx" #include "moon/vector2.hxx" #include "moon/vector4.hxx" -#include "moon/string.hxx" +#include "moon/vertex_buffer.hxx" +#include namespace Moon { - class Font { - public: - texture_font_t *font; - texture_atlas_t *atlas; +class Font +{ +public: + texture_font_t* font; + texture_atlas_t* atlas; - Font(const std::string &name, const int font_size); - ~Font(); + Font(const std::string& name, const int font_size); + ~Font(); - int GetSize(); - Vector2 ComputeStringBbox(const String &text, const float line_height); - void FillTextBuffer(VertexBuffer *vbo, const String &text, const Vector4 &c, const float x, const float y, const float line_height); - void Bind(); - private: - }; + int GetSize(); + Vector2 ComputeStringBbox(const String& text, const float line_height); + void FillTextBuffer(VertexBuffer* vbo, const String& text, const Vector4& c, + const float x, const float y, const float line_height); + void Bind(); + +private: +}; }; #endif diff --git a/modules/graphics/include/moon/graphics.hxx b/modules/graphics/include/moon/graphics.hxx index 1084f11..7172738 100644 --- a/modules/graphics/include/moon/graphics.hxx +++ b/modules/graphics/include/moon/graphics.hxx @@ -5,17 +5,17 @@ #include "moon/vector4.hxx" namespace Moon { - struct Vertex { - Vector2 pos; - Vector2 tex_coord; - Vector4 color; +struct Vertex +{ + Vector2 pos; + Vector2 tex_coord; + Vector4 color; - Vertex() {}; - Vertex(Vector2 _pos, Vector2 _tex_coord, Vector4 _color) : - pos(_pos), - tex_coord(_tex_coord), - color(_color) - {}; - }; + Vertex(){}; + Vertex(Vector2 _pos, Vector2 _tex_coord, Vector4 _color) + : pos(_pos) + , tex_coord(_tex_coord) + , color(_color){}; +}; } #endif diff --git a/modules/graphics/include/moon/mrb/font.hxx b/modules/graphics/include/moon/mrb/font.hxx index 2ad4a90..4839a05 100644 --- a/modules/graphics/include/moon/mrb/font.hxx +++ b/modules/graphics/include/moon/mrb/font.hxx @@ -1,17 +1,17 @@ #ifndef MMRB_FONT_H #define MMRB_FONT_H +#include "moon/api.h" +#include "moon/font.hxx" #include #include #include -#include "moon/api.h" -#include "moon/font.hxx" MOON_C_API const struct mrb_data_type font_data_type; -MOON_C_API void mmrb_font_init(mrb_state *mrb); +MOON_C_API void mmrb_font_init(mrb_state* mrb); static inline Moon::Font* -mmrb_font_ptr(mrb_state *mrb, mrb_value self) +mmrb_font_ptr(mrb_state* mrb, mrb_value self) { return static_cast(mrb_data_get_ptr(mrb, self, &font_data_type)); } diff --git a/modules/graphics/include/moon/mrb/shader.hxx b/modules/graphics/include/moon/mrb/shader.hxx index 068a4ce..3c9709b 100644 --- a/modules/graphics/include/moon/mrb/shader.hxx +++ b/modules/graphics/include/moon/mrb/shader.hxx @@ -1,19 +1,20 @@ #ifndef MMRB_SHADER_H #define MMRB_SHADER_H +#include "moon/api.h" +#include "moon/shader.hxx" #include #include #include -#include "moon/api.h" -#include "moon/shader.hxx" MOON_C_API const struct mrb_data_type shader_data_type; -MOON_C_API void mmrb_shader_init(mrb_state *mrb); +MOON_C_API void mmrb_shader_init(mrb_state* mrb); static inline Moon::Shader* -mmrb_shader_ptr(mrb_state *mrb, mrb_value self) +mmrb_shader_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &shader_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &shader_data_type)); } #endif diff --git a/modules/graphics/include/moon/mrb/texture.hxx b/modules/graphics/include/moon/mrb/texture.hxx index 326741e..113d6da 100644 --- a/modules/graphics/include/moon/mrb/texture.hxx +++ b/modules/graphics/include/moon/mrb/texture.hxx @@ -1,34 +1,35 @@ #ifndef MMRB_TEXTURE_H #define MMRB_TEXTURE_H +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" +#include "moon/texture.hxx" #include #include #include -#include "moon/api.h" -#include "moon/texture.hxx" -#include "moon/mrb/helpers.hxx" #define KEY_TEXTURE "@texture" static inline struct RClass* -mmrb_get_texture_class(mrb_state *mrb) +mmrb_get_texture_class(mrb_state* mrb) { return MOON_GET_CLASS("Texture"); } - MOON_C_API const struct mrb_data_type texture_data_type; -MOON_C_API void mmrb_texture_init(mrb_state *mrb); -MOON_C_API mrb_value mmrb_texture_load_file(mrb_state *mrb, const char *filename); +MOON_C_API void mmrb_texture_init(mrb_state* mrb); +MOON_C_API mrb_value mmrb_texture_load_file(mrb_state* mrb, + const char* filename); static inline Moon::Texture* -mmrb_texture_ptr(mrb_state *mrb, mrb_value self) +mmrb_texture_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &texture_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &texture_data_type)); } static void -mmrb_check_texture(mrb_state *mrb, Moon::Texture *texture) +mmrb_check_texture(mrb_state* mrb, Moon::Texture* texture) { if (!texture->GetID()) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid texture handle."); @@ -36,9 +37,9 @@ mmrb_check_texture(mrb_state *mrb, Moon::Texture *texture) } static inline Moon::Texture* -mmrb_valid_texture_ptr(mrb_state *mrb, mrb_value obj) +mmrb_valid_texture_ptr(mrb_state* mrb, mrb_value obj) { - Moon::Texture *texture = mmrb_texture_ptr(mrb, obj); + Moon::Texture* texture = mmrb_texture_ptr(mrb, obj); mmrb_check_texture(mrb, texture); return texture; } diff --git a/modules/graphics/include/moon/mrb/vertex_buffer.hxx b/modules/graphics/include/moon/mrb/vertex_buffer.hxx index a38632b..55b9775 100644 --- a/modules/graphics/include/moon/mrb/vertex_buffer.hxx +++ b/modules/graphics/include/moon/mrb/vertex_buffer.hxx @@ -1,19 +1,20 @@ #ifndef MMRB_VBO_H #define MMRB_VBO_H +#include "moon/api.h" +#include "moon/vertex_buffer.hxx" #include #include #include -#include "moon/api.h" -#include "moon/vertex_buffer.hxx" MOON_C_API const struct mrb_data_type vbo_data_type; -MOON_C_API void mmrb_vbo_init(mrb_state *mrb); +MOON_C_API void mmrb_vbo_init(mrb_state* mrb); static inline Moon::VertexBuffer* -mmrb_vertex_buffer_ptr(mrb_state *mrb, mrb_value self) +mmrb_vertex_buffer_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &vbo_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &vbo_data_type)); } #endif diff --git a/modules/graphics/include/moon/shader.hxx b/modules/graphics/include/moon/shader.hxx index d53ca87..55d3718 100644 --- a/modules/graphics/include/moon/shader.hxx +++ b/modules/graphics/include/moon/shader.hxx @@ -1,48 +1,52 @@ #ifndef MOON_SHADER_H #define MOON_SHADER_H -#include -#include -#include -#include -#include "moon/intern.h" #include "moon/gl.h" #include "moon/glm.h" +#include "moon/intern.h" +#include "moon/matrix4.hxx" #include "moon/vector1.hxx" #include "moon/vector2.hxx" #include "moon/vector3.hxx" #include "moon/vector4.hxx" -#include "moon/matrix4.hxx" +#include +#include +#include +#include namespace Moon { - class Shader { - typedef std::unordered_map AttributeMap; - public: - static bool is_legacy; +class Shader +{ + typedef std::unordered_map AttributeMap; - Shader(const std::string vertexShader, const std::string fragmentShader); - ~Shader(); - void Use(); - GLint Attribute(std::string name); - GLint Uniform(std::string name); +public: + static bool is_legacy; - void SetUniform(std::string name, const GLint v1); - void SetUniform(std::string name, const GLfloat v1); - //void SetUniform(std::string name, const Moon::Vector1 &vec); - void SetUniform(std::string name, const Moon::Vector2 &vec); - void SetUniform(std::string name, const Moon::Vector3 &vec); - void SetUniform(std::string name, const Moon::Vector4 &vec); - void SetUniform(std::string name, const Moon::Matrix4 &mat); - private: - GLuint m_program; - AttributeMap m_attributeList; - AttributeMap m_uniformLocationList; + Shader(const std::string vertexShader, const std::string fragmentShader); + ~Shader(); + void Use(); + GLint Attribute(std::string name); + GLint Uniform(std::string name); - void PrintLog(GLuint object); - GLuint CreateShader(const std::string contents, GLenum type); - GLuint CreateProgram(const std::string vertexShader, const std::string fragmentShader); - GLint InitAttribute(std::string name); - GLint InitUniform(std::string name); - }; + void SetUniform(std::string name, const GLint v1); + void SetUniform(std::string name, const GLfloat v1); + // void SetUniform(std::string name, const Moon::Vector1 &vec); + void SetUniform(std::string name, const Moon::Vector2& vec); + void SetUniform(std::string name, const Moon::Vector3& vec); + void SetUniform(std::string name, const Moon::Vector4& vec); + void SetUniform(std::string name, const Moon::Matrix4& mat); + +private: + GLuint m_program; + AttributeMap m_attributeList; + AttributeMap m_uniformLocationList; + + void PrintLog(GLuint object); + GLuint CreateShader(const std::string contents, GLenum type); + GLuint CreateProgram(const std::string vertexShader, + const std::string fragmentShader); + GLint InitAttribute(std::string name); + GLint InitUniform(std::string name); +}; }; #endif diff --git a/modules/graphics/include/moon/texture.hxx b/modules/graphics/include/moon/texture.hxx index 6af7d97..96acdbc 100644 --- a/modules/graphics/include/moon/texture.hxx +++ b/modules/graphics/include/moon/texture.hxx @@ -1,27 +1,29 @@ #ifndef MOON_TEXTURE_H #define MOON_TEXTURE_H -#include -#include -#include "moon/intern.h" #include "moon/gl.h" +#include "moon/intern.h" #include "moon/shader.hxx" #include "moon/vertex_buffer.hxx" +#include +#include namespace Moon { - class Texture { - public: - Texture(std::string filename); - ~Texture(); - void Bind(); - GLint GetWidth(); - GLint GetHeight(); - GLuint GetID(); - private: - GLint m_width; - GLint m_height; - GLuint m_gl_texture_id; - }; +class Texture +{ +public: + Texture(std::string filename); + ~Texture(); + void Bind(); + GLint GetWidth(); + GLint GetHeight(); + GLuint GetID(); + +private: + GLint m_width; + GLint m_height; + GLuint m_gl_texture_id; +}; }; #endif diff --git a/modules/graphics/include/moon/vertex_buffer.hxx b/modules/graphics/include/moon/vertex_buffer.hxx index b08ec4b..e3cb0d5 100644 --- a/modules/graphics/include/moon/vertex_buffer.hxx +++ b/modules/graphics/include/moon/vertex_buffer.hxx @@ -1,41 +1,47 @@ #ifndef MOON_VERTBUFFER_H #define MOON_VERTBUFFER_H -#include -#include -#include -#include "moon/intern.h" #include "moon/gl.h" #include "moon/graphics.hxx" +#include "moon/intern.h" #include "moon/vector3.hxx" +#include +#include +#include namespace Moon { - class VertexBuffer { - public: - VertexBuffer(GLenum usage); // STATIC_DRAW, DYNAMIC_DRAW... - ~VertexBuffer(); - void Render(GLenum mode); - void Render(GLenum mode, const int offset); // adds offset to the indices used (draws vertex at vbo[indice + offset]) - void PushBack(Vertex v); - void PushBackVertices(Vertex *v, int vertex_count); - void PushBackIndices(GLuint i[], int index_count); - void PushBack(Vertex *v, int vertex_count, GLuint i[], int index_count); // indices need to be relative to the vertices pushed in - Vertex GetVertex(const int index); - GLuint GetIndex(const int index); - GLuint GetVertexCount(); - GLuint GetIndexCount(); - void Clear(); - void Upload(); - private: - GLuint m_vao_id; - GLuint m_vbo_id; - GLuint m_ibo_id; - GLenum m_usage; - bool m_dirty; // do we need to reupload? - std::vector m_vertices; - std::vector m_indices; - void Setup(); // set up the VAO - }; +class VertexBuffer +{ +public: + VertexBuffer(GLenum usage); // STATIC_DRAW, DYNAMIC_DRAW... + ~VertexBuffer(); + void Render(GLenum mode); + void Render(GLenum mode, const int offset); // adds offset to the indices used + // (draws vertex at vbo[indice + + // offset]) + void PushBack(Vertex v); + void PushBackVertices(Vertex* v, int vertex_count); + void PushBackIndices(GLuint i[], int index_count); + void PushBack( + Vertex* v, int vertex_count, GLuint i[], + int index_count); // indices need to be relative to the vertices pushed in + Vertex GetVertex(const int index); + GLuint GetIndex(const int index); + GLuint GetVertexCount(); + GLuint GetIndexCount(); + void Clear(); + void Upload(); + +private: + GLuint m_vao_id; + GLuint m_vbo_id; + GLuint m_ibo_id; + GLenum m_usage; + bool m_dirty; // do we need to reupload? + std::vector m_vertices; + std::vector m_indices; + void Setup(); // set up the VAO +}; }; #endif diff --git a/modules/graphics/src/font.cxx b/modules/graphics/src/font.cxx index 9ed49ea..090c32b 100644 --- a/modules/graphics/src/font.cxx +++ b/modules/graphics/src/font.cxx @@ -1,141 +1,152 @@ -#include +#include "moon/font.hxx" #include "moon/gl.h" #include "moon/glm.h" -#include "moon/font.hxx" #include "moon/string.hxx" #include "moon/vector2.hxx" #include "moon/vector4.hxx" +#include #define isNewline(_char_) ((_char_) == '\n' || (_char_) == '\r') namespace Moon { - Font::Font(const std::string &filename, const int font_size) - { - atlas = texture_atlas_new(1024, 1024, 1); - font = texture_font_new_from_file(atlas, font_size, filename.c_str()); - texture_font_load_glyphs(font, " !\"#$%&'()*+,-./0123456789:;<=>?" - "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" - "`abcdefghijklmnopqrstuvwxyz{|}~"); - texture_atlas_upload(atlas); - } +Font::Font(const std::string& filename, const int font_size) +{ + atlas = texture_atlas_new(1024, 1024, 1); + font = texture_font_new_from_file(atlas, font_size, filename.c_str()); + texture_font_load_glyphs(font, " !\"#$%&'()*+,-./0123456789:;<=>?" + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" + "`abcdefghijklmnopqrstuvwxyz{|}~"); + texture_atlas_upload(atlas); +} - Font::~Font() { - texture_font_delete(font); - texture_atlas_delete(atlas); - } +Font::~Font() +{ + texture_font_delete(font); + texture_atlas_delete(atlas); +} - void Font::FillTextBuffer(VertexBuffer *vbo, const String &text, const Vector4 &c, - const float x, const float y, const float line_height) { - const float line_space = line_height * font->size; - float cursor = 0; // position of the write cursor - float line = 0; - for(size_t i = 0; i < text.length(); ++i) { - if (isNewline(text[i])) { - cursor = 0; - line += line_space; - continue; - } +void +Font::FillTextBuffer(VertexBuffer* vbo, const String& text, const Vector4& c, + const float x, const float y, const float line_height) +{ + const float line_space = line_height * font->size; + float cursor = 0; // position of the write cursor + float line = 0; + for (size_t i = 0; i < text.length(); ++i) { + if (isNewline(text[i])) { + cursor = 0; + line += line_space; + continue; + } - texture_glyph_t *glyph = texture_font_get_glyph(font, text.get_cptr(i)); - if (glyph != NULL) { - float kerning = 0; - if (i > 0) { - kerning = texture_glyph_get_kerning(glyph, text.get_cptr(i - 1)); - } - cursor += kerning; - float x0 = x + cursor + glyph->offset_x; - float y0 = y + line - glyph->offset_y; - float x1 = x0 + glyph->width; - float y1 = y0 + glyph->height; - - float s0 = glyph->s0; - float t0 = glyph->t0; - float s1 = glyph->s1; - float t1 = glyph->t1; - - GLuint indices[6] = {0,1,2, 0,2,3}; - Vertex vertices[4] = { {{x0,y0}, {s0,t0}, c}, - {{x0,y1}, {s0,t1}, c}, - {{x1,y1}, {s1,t1}, c}, - {{x1,y0}, {s1,t0}, c} }; - vbo->PushBack(vertices, 4, indices, 6); - cursor += glyph->advance_x; + texture_glyph_t* glyph = texture_font_get_glyph(font, text.get_cptr(i)); + if (glyph != NULL) { + float kerning = 0; + if (i > 0) { + kerning = texture_glyph_get_kerning(glyph, text.get_cptr(i - 1)); } + cursor += kerning; + float x0 = x + cursor + glyph->offset_x; + float y0 = y + line - glyph->offset_y; + float x1 = x0 + glyph->width; + float y1 = y0 + glyph->height; + + float s0 = glyph->s0; + float t0 = glyph->t0; + float s1 = glyph->s1; + float t1 = glyph->t1; + + GLuint indices[6] = { 0, 1, 2, 0, 2, 3 }; + Vertex vertices[4] = { { { x0, y0 }, { s0, t0 }, c }, + { { x0, y1 }, { s0, t1 }, c }, + { { x1, y1 }, { s1, t1 }, c }, + { { x1, y0 }, { s1, t0 }, c } }; + vbo->PushBack(vertices, 4, indices, 6); + cursor += glyph->advance_x; } - // upload to the buffer, we might have loaded more glyphs - texture_atlas_upload(atlas); } + // upload to the buffer, we might have loaded more glyphs + texture_atlas_upload(atlas); +} - Vector2 Font::ComputeStringBbox(const String &text, const float line_height) { - Vector4 bbox; - const float line_space = line_height * font->size; - float cursor = 0; // position of the write cursor - float line = 0; - - /* initialize string bbox to "empty" values */ - bbox.x = bbox.y = 32000; - bbox.z = bbox.w = -32000; - - /* for each glyph image, compute its bounding box, */ - /* translate it, and grow the string bbox */ - for (size_t i = 0; i < text.length(); ++i) { - if (isNewline(text[i])) { - if (cursor > bbox.z) bbox.z = cursor; - cursor = 0; - line += line_space; - continue; - } - - texture_glyph_t *glyph = texture_font_get_glyph(font, text.get_cptr(i)); +Vector2 +Font::ComputeStringBbox(const String& text, const float line_height) +{ + Vector4 bbox; + const float line_space = line_height * font->size; + float cursor = 0; // position of the write cursor + float line = 0; + + /* initialize string bbox to "empty" values */ + bbox.x = bbox.y = 32000; + bbox.z = bbox.w = -32000; + + /* for each glyph image, compute its bounding box, */ + /* translate it, and grow the string bbox */ + for (size_t i = 0; i < text.length(); ++i) { + if (isNewline(text[i])) { + if (cursor > bbox.z) + bbox.z = cursor; + cursor = 0; + line += line_space; + continue; + } - if (glyph != NULL) { - float kerning = 0; - if(i > 0) { - kerning = texture_glyph_get_kerning(glyph, text.get_cptr(i - 1)); - } - cursor += kerning; - float x0 = cursor + glyph->offset_x; - float y0 = line - glyph->offset_y; - float x1 = x0 + glyph->width; - float y1 = y0 + glyph->height; + texture_glyph_t* glyph = texture_font_get_glyph(font, text.get_cptr(i)); - if (x0 < bbox.x) - bbox.x = x0; + if (glyph != NULL) { + float kerning = 0; + if (i > 0) { + kerning = texture_glyph_get_kerning(glyph, text.get_cptr(i - 1)); + } + cursor += kerning; + float x0 = cursor + glyph->offset_x; + float y0 = line - glyph->offset_y; + float x1 = x0 + glyph->width; + float y1 = y0 + glyph->height; - if (y0 < bbox.y) - bbox.y = y0; + if (x0 < bbox.x) + bbox.x = x0; - if (x1 > bbox.z) - bbox.z = x1; + if (y0 < bbox.y) + bbox.y = y0; - if (y1 > bbox.w) - bbox.w = y1; + if (x1 > bbox.z) + bbox.z = x1; - cursor += glyph->advance_x; - } - } + if (y1 > bbox.w) + bbox.w = y1; - /* check that we really grew the string bbox */ - if (bbox.x > bbox.z) { - bbox.x = 0; - bbox.y = 0; - bbox.z = 0; - bbox.w = 0; - } else { - // adjusts bbox.z position to compensate for the last character - // glyph->advance_x - if (cursor > bbox.z) bbox.z = cursor; + cursor += glyph->advance_x; } - - /* return string bbox */ - return glm::vec2(bbox.z - bbox.x, bbox.w - bbox.y); } - int Font::GetSize() { - return font->size; + /* check that we really grew the string bbox */ + if (bbox.x > bbox.z) { + bbox.x = 0; + bbox.y = 0; + bbox.z = 0; + bbox.w = 0; + } else { + // adjusts bbox.z position to compensate for the last character + // glyph->advance_x + if (cursor > bbox.z) + bbox.z = cursor; } - void Font::Bind() { - glBindTexture(GL_TEXTURE_2D, atlas->id); - } + /* return string bbox */ + return glm::vec2(bbox.z - bbox.x, bbox.w - bbox.y); +} + +int +Font::GetSize() +{ + return font->size; +} + +void +Font::Bind() +{ + glBindTexture(GL_TEXTURE_2D, atlas->id); +} } diff --git a/modules/graphics/src/mrb_font.cxx b/modules/graphics/src/mrb_font.cxx index 2db76e4..496f31b 100644 --- a/modules/graphics/src/mrb_font.cxx +++ b/modules/graphics/src/mrb_font.cxx @@ -1,31 +1,32 @@ -#include -#include -#include -#include -#include -#include -#include #include "moon/api.h" +#include "moon/font.hxx" +#include "moon/glm.h" #include "moon/mrb/font.hxx" +#include "moon/mrb/helpers.hxx" #include "moon/mrb/matrix4.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" -#include "moon/glm.h" #include "moon/string.hxx" -#include "moon/font.hxx" -#include "moon/mrb/helpers.hxx" +#include +#include +#include +#include +#include +#include +#include static void -font_free(mrb_state *mrb, void *p) +font_free(mrb_state* mrb, void* p) { - Moon::Font *font = (Moon::Font*)p; + Moon::Font* font = (Moon::Font*)p; if (font) { - delete(font); + delete (font); } } -MOON_C_API const struct mrb_data_type font_data_type = { "Moon::Font", font_free }; +MOON_C_API const struct mrb_data_type font_data_type = { "Moon::Font", + font_free }; /* * Calculates the string's width and height in pixel using the font. @@ -34,11 +35,11 @@ MOON_C_API const struct mrb_data_type font_data_type = { "Moon::Font", font_free * @param [Integer] font_size Desired font size */ static mrb_value -font_initialize(mrb_state *mrb, mrb_value self) +font_initialize(mrb_state* mrb, mrb_value self) { char* filename; mrb_int font_size; - Moon::Font *font = NULL; + Moon::Font* font = NULL; font_free(mrb, DATA_PTR(self)); DATA_PTR(self) = NULL; @@ -47,9 +48,8 @@ font_initialize(mrb_state *mrb, mrb_value self) if (exists(std::string(filename))) { font = new Moon::Font(filename, font_size); } else { - mrb_raisef(mrb, E_SCRIPT_ERROR, - "cannot load such file -- %S", - mrb_str_new_cstr(mrb, filename)); + mrb_raisef(mrb, E_SCRIPT_ERROR, "cannot load such file -- %S", + mrb_str_new_cstr(mrb, filename)); } // This should never happen if (!font) { @@ -64,7 +64,7 @@ font_initialize(mrb_state *mrb, mrb_value self) * @return [Integer] */ static mrb_value -font_size(mrb_state *mrb, mrb_value self) +font_size(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_font_ptr(mrb, self)->GetSize()); } @@ -77,16 +77,17 @@ font_size(mrb_state *mrb, mrb_value self) * @return [Array[2]] */ static mrb_value -font_calc_bounds(mrb_state *mrb, mrb_value self) +font_calc_bounds(mrb_state* mrb, mrb_value self) { - char *str; + char* str; mrb_float line_height = 1.2; mrb_get_args(mrb, "z|f", &str, &line_height); // convert to wide char (UTF-8) Moon::String text(str); - Moon::Font *font = mmrb_font_ptr(mrb, self); + Moon::Font* font = mmrb_font_ptr(mrb, self); Moon::Vector2 bounds = font->ComputeStringBbox(text, line_height); - mrb_value argv[2] = { mrb_fixnum_value(bounds.x), mrb_fixnum_value(bounds.y) }; + mrb_value argv[2] = { mrb_fixnum_value(bounds.x), + mrb_fixnum_value(bounds.y) }; return mrb_ary_new_from_values(mrb, 2, argv); } @@ -96,7 +97,7 @@ font_calc_bounds(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -font_ascender_get(mrb_state *mrb, mrb_value self) +font_ascender_get(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_font_ptr(mrb, self)->font->ascender); } @@ -107,25 +108,29 @@ font_ascender_get(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -font_bind(mrb_state *mrb, mrb_value self) +font_bind(mrb_state* mrb, mrb_value self) { mmrb_font_ptr(mrb, self)->Bind(); return self; } MOON_C_API void -mmrb_font_init(mrb_state *mrb) +mmrb_font_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); + struct RClass* mod = mrb_define_module(mrb, "Moon"); /* Class for loading and rendering font files * Supported formats are .ttf and possibly .otf */ - struct RClass *font_class = mrb_define_class_under(mrb, mod, "Font", mrb->object_class); + struct RClass* font_class = + mrb_define_class_under(mrb, mod, "Font", mrb->object_class); MRB_SET_INSTANCE_TT(font_class, MRB_TT_DATA); - mrb_define_method(mrb, font_class, "initialize", font_initialize, MRB_ARGS_REQ(2)); - mrb_define_method(mrb, font_class, "size", font_size, MRB_ARGS_NONE()); - mrb_define_method(mrb, font_class, "calc_bounds", font_calc_bounds, MRB_ARGS_ARG(1,1)); - mrb_define_method(mrb, font_class, "ascender", font_ascender_get, MRB_ARGS_NONE()); - mrb_define_method(mrb, font_class, "bind", font_bind, MRB_ARGS_NONE()); + mrb_define_method(mrb, font_class, "initialize", font_initialize, + MRB_ARGS_REQ(2)); + mrb_define_method(mrb, font_class, "size", font_size, MRB_ARGS_NONE()); + mrb_define_method(mrb, font_class, "calc_bounds", font_calc_bounds, + MRB_ARGS_ARG(1, 1)); + mrb_define_method(mrb, font_class, "ascender", font_ascender_get, + MRB_ARGS_NONE()); + mrb_define_method(mrb, font_class, "bind", font_bind, MRB_ARGS_NONE()); } diff --git a/modules/graphics/src/mrb_graphics.cxx b/modules/graphics/src/mrb_graphics.cxx index 6a8e295..17ca3d4 100644 --- a/modules/graphics/src/mrb_graphics.cxx +++ b/modules/graphics/src/mrb_graphics.cxx @@ -1,18 +1,18 @@ -#include -#include -#include "moon/mrb/vertex_buffer.hxx" #include "moon/mrb/font.hxx" #include "moon/mrb/shader.hxx" #include "moon/mrb/texture.hxx" +#include "moon/mrb/vertex_buffer.hxx" +#include +#include -MOON_C_API void mmrb_sprite_init(mrb_state *mrb); -MOON_C_API void mmrb_spritesheet_init(mrb_state *mrb); -MOON_C_API void mmrb_text_init(mrb_state *mrb); +MOON_C_API void mmrb_sprite_init(mrb_state* mrb); +MOON_C_API void mmrb_spritesheet_init(mrb_state* mrb); +MOON_C_API void mmrb_text_init(mrb_state* mrb); MOON_C_API void mrb_mruby_moon_graphics_gem_init(mrb_state* mrb) { - struct RClass *moon_module = mrb_define_module(mrb, "Moon"); + struct RClass* moon_module = mrb_define_module(mrb, "Moon"); mmrb_vbo_init(mrb); mmrb_shader_init(mrb); mmrb_font_init(mrb); diff --git a/modules/graphics/src/mrb_shader.cxx b/modules/graphics/src/mrb_shader.cxx index 836bb45..3e19b3d 100644 --- a/modules/graphics/src/mrb_shader.cxx +++ b/modules/graphics/src/mrb_shader.cxx @@ -1,35 +1,37 @@ -#include -#include -#include -#include "moon/shader.hxx" +#include "moon/mrb/helpers.hxx" +#include "moon/mrb/matrix4.hxx" #include "moon/mrb/shader.hxx" #include "moon/mrb/vector1.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" -#include "moon/mrb/matrix4.hxx" -#include "moon/mrb/helpers.hxx" +#include "moon/shader.hxx" +#include +#include +#include static void -shader_free(mrb_state *mrb, void *ptr) +shader_free(mrb_state* mrb, void* ptr) { - Moon::Shader *shader = static_cast(ptr); + Moon::Shader* shader = static_cast(ptr); if (shader) { delete shader; } } -MOON_C_API const struct mrb_data_type shader_data_type = { "Moon::Shader", shader_free }; +MOON_C_API const struct mrb_data_type shader_data_type = { "Moon::Shader", + shader_free }; -/* Initializes a new shader object, generating a vertex and fragment shader pair. +/* Initializes a new shader object, generating a vertex and fragment shader + * pair. * * @param [String] vertexShader contents of the vertex shader program * @param [String] fragmentShader contents of the fragment shader program */ static mrb_value -shader_initialize(mrb_state *mrb, mrb_value self) +shader_initialize(mrb_state* mrb, mrb_value self) { - Moon::Shader *shader; + Moon::Shader* shader; char* vertexShader; char* fragmentShader; shader_free(mrb, DATA_PTR(self)); @@ -46,7 +48,7 @@ shader_initialize(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -shader_use(mrb_state *mrb, mrb_value self) +shader_use(mrb_state* mrb, mrb_value self) { mmrb_shader_ptr(mrb, self)->Use(); return self; @@ -60,11 +62,11 @@ shader_use(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -shader_set_uniform(mrb_state *mrb, mrb_value self) +shader_set_uniform(mrb_state* mrb, mrb_value self) { - char *cname; + char* cname; mrb_value data; - Moon::Shader *shader; + Moon::Shader* shader; mrb_get_args(mrb, "zo", &cname, &data); shader = mmrb_shader_ptr(mrb, self); std::string name(cname); @@ -77,41 +79,48 @@ shader_set_uniform(mrb_state *mrb, mrb_value self) shader->SetUniform(name, static_cast(mrb_to_flo(mrb, data))); } break; case MRB_TT_DATA: { - void *ptr; + void* ptr; /*if ((ptr = mrb_data_check_get_ptr(mrb, data, &vector1_data_type))) { shader->SetUniform(name, *static_cast(ptr)); - } else */if ((ptr = mrb_data_check_get_ptr(mrb, data, &vector2_data_type))) { + } else */ if ((ptr = + mrb_data_check_get_ptr(mrb, data, &vector2_data_type))) { shader->SetUniform(name, *static_cast(ptr)); - } else if ((ptr = mrb_data_check_get_ptr(mrb, data, &vector3_data_type))) { + } else if ((ptr = + mrb_data_check_get_ptr(mrb, data, &vector3_data_type))) { shader->SetUniform(name, *static_cast(ptr)); - } else if ((ptr = mrb_data_check_get_ptr(mrb, data, &vector4_data_type))) { + } else if ((ptr = + mrb_data_check_get_ptr(mrb, data, &vector4_data_type))) { shader->SetUniform(name, *static_cast(ptr)); - } else if ((ptr = mrb_data_check_get_ptr(mrb, data, &matrix4_data_type))) { + } else if ((ptr = + mrb_data_check_get_ptr(mrb, data, &matrix4_data_type))) { shader->SetUniform(name, *static_cast(ptr)); } else { - mrb_raisef(mrb, E_TYPE_ERROR, "unexpected object %S (expected Vector4 or Matrix4)", mrb_obj_classname(mrb, data)); + mrb_raisef(mrb, E_TYPE_ERROR, + "unexpected object %S (expected Vector4 or Matrix4)", + mrb_obj_classname(mrb, data)); } } break; default: - mrb_raisef(mrb, E_TYPE_ERROR, "unexpected object %S", mrb_obj_classname(mrb, data)); + mrb_raisef(mrb, E_TYPE_ERROR, "unexpected object %S", + mrb_obj_classname(mrb, data)); break; } return self; } static mrb_value -shader_s_is_legacy_get(mrb_state *mrb, mrb_value klass) +shader_s_is_legacy_get(mrb_state* mrb, mrb_value klass) { return mrb_bool_value(Moon::Shader::is_legacy); } static mrb_value -shader_s_is_legacy_set(mrb_state *mrb, mrb_value klass) +shader_s_is_legacy_set(mrb_state* mrb, mrb_value klass) { mrb_bool leg; mrb_get_args(mrb, "b", &leg); @@ -120,16 +129,21 @@ shader_s_is_legacy_set(mrb_state *mrb, mrb_value klass) } MOON_C_API void -mmrb_shader_init(mrb_state *mrb) +mmrb_shader_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *shader_class = mrb_define_class_under(mrb, mod, "Shader", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* shader_class = + mrb_define_class_under(mrb, mod, "Shader", mrb->object_class); MRB_SET_INSTANCE_TT(shader_class, MRB_TT_DATA); - mrb_define_method(mrb, shader_class, "initialize", shader_initialize, MRB_ARGS_REQ(2)); - mrb_define_method(mrb, shader_class, "use", shader_use, MRB_ARGS_NONE()); - mrb_define_method(mrb, shader_class, "set_uniform", shader_set_uniform, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, shader_class, "initialize", shader_initialize, + MRB_ARGS_REQ(2)); + mrb_define_method(mrb, shader_class, "use", shader_use, MRB_ARGS_NONE()); + mrb_define_method(mrb, shader_class, "set_uniform", shader_set_uniform, + MRB_ARGS_REQ(2)); - mrb_define_class_method(mrb, shader_class, "is_legacy", shader_s_is_legacy_get, MRB_ARGS_NONE()); - mrb_define_class_method(mrb, shader_class, "is_legacy=", shader_s_is_legacy_set, MRB_ARGS_REQ(1)); + mrb_define_class_method(mrb, shader_class, "is_legacy", + shader_s_is_legacy_get, MRB_ARGS_NONE()); + mrb_define_class_method(mrb, shader_class, "is_legacy=", + shader_s_is_legacy_set, MRB_ARGS_REQ(1)); } diff --git a/modules/graphics/src/mrb_sprite.cxx b/modules/graphics/src/mrb_sprite.cxx index 7faa125..2ed41e9 100644 --- a/modules/graphics/src/mrb_sprite.cxx +++ b/modules/graphics/src/mrb_sprite.cxx @@ -1,13 +1,6 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include "moon/glm.h" #include "moon/api.h" +#include "moon/glm.h" +#include "moon/mrb/helpers.hxx" #include "moon/mrb/rect.hxx" #include "moon/mrb/shader.hxx" #include "moon/mrb/texture.hxx" @@ -15,58 +8,69 @@ #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" #include "moon/mrb/vertex_buffer.hxx" -#include "moon/mrb/helpers.hxx" #include "moon/mrb_err.hxx" +#include +#include +#include +#include +#include +#include +#include +#include static mrb_value -sprite_generate_buffers(mrb_state *mrb, mrb_value self) +sprite_generate_buffers(mrb_state* mrb, mrb_value self) { - Moon::Texture *texture = mmrb_valid_texture_ptr(mrb, moon_iv_get(mrb, self, KEY_TEXTURE)); - Moon::VertexBuffer *vbo = mmrb_vertex_buffer_ptr(mrb, moon_iv_get(mrb, self, KEY_VBO)); + Moon::Texture* texture = + mmrb_valid_texture_ptr(mrb, moon_iv_get(mrb, self, KEY_TEXTURE)); + Moon::VertexBuffer* vbo = + mmrb_vertex_buffer_ptr(mrb, moon_iv_get(mrb, self, KEY_VBO)); mrb_value clip = IVget("@clip_rect"); vbo->Clear(); - //Texture coordinates + // Texture coordinates GLfloat s0 = 0.f; GLfloat s1 = 1.f; GLfloat t0 = 0.f; GLfloat t1 = 1.f; - //Vertex coordinates + // Vertex coordinates GLfloat width = texture->GetWidth(); GLfloat height = texture->GetHeight(); - //Handle clipping + // Handle clipping if (!mrb_nil_p(clip)) { // TODO: get C++ clip rect from mrb rect - Moon::IntRect *clip_rect = mmrb_rect_ptr(mrb, clip); + Moon::IntRect* clip_rect = mmrb_rect_ptr(mrb, clip); - //Texture coordinates + // Texture coordinates s0 = (float)clip_rect->x / texture->GetWidth(); s1 = (float)(clip_rect->x + clip_rect->w) / texture->GetWidth(); t0 = (float)clip_rect->y / texture->GetHeight(); t1 = (float)(clip_rect->y + clip_rect->h) / texture->GetHeight(); - //Vertex coordinates + // Vertex coordinates width = clip_rect->w; height = clip_rect->h; } Moon::Vertex vertices[4] = { - { {0.f, 0.f}, {s0, t0}, Moon::Vector4(1, 1, 1, 1) }, - { {width, 0.f}, {s1, t0}, Moon::Vector4(1, 1, 1, 1) }, - { {width, height}, {s1, t1}, Moon::Vector4(1, 1, 1, 1) }, - { {0.f, height}, {s0, t1}, Moon::Vector4(1, 1, 1, 1) } + { { 0.f, 0.f }, { s0, t0 }, Moon::Vector4(1, 1, 1, 1) }, + { { width, 0.f }, { s1, t0 }, Moon::Vector4(1, 1, 1, 1) }, + { { width, height }, { s1, t1 }, Moon::Vector4(1, 1, 1, 1) }, + { { 0.f, height }, { s0, t1 }, Moon::Vector4(1, 1, 1, 1) } }; - GLuint indices[4] = {0, 1, 3, 2}; // rendering indices + GLuint indices[4] = { 0, 1, 3, 2 }; // rendering indices vbo->PushBack(vertices, 4, indices, 4); return self; } MOON_C_API void -mmrb_sprite_init(mrb_state *mrb) +mmrb_sprite_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *sprite_class = mrb_define_class_under(mrb, mod, "Sprite", mrb->object_class); - mrb_define_method(mrb, sprite_class, "generate_buffers", sprite_generate_buffers, MRB_ARGS_NONE()); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* sprite_class = + mrb_define_class_under(mrb, mod, "Sprite", mrb->object_class); + mrb_define_method(mrb, sprite_class, "generate_buffers", + sprite_generate_buffers, MRB_ARGS_NONE()); } diff --git a/modules/graphics/src/mrb_spritesheet.cxx b/modules/graphics/src/mrb_spritesheet.cxx index 47bd78b..6bc1c43 100644 --- a/modules/graphics/src/mrb_spritesheet.cxx +++ b/modules/graphics/src/mrb_spritesheet.cxx @@ -1,13 +1,6 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include "moon/glm.h" #include "moon/api.h" +#include "moon/glm.h" +#include "moon/mrb/helpers.hxx" #include "moon/mrb/matrix4.hxx" #include "moon/mrb/shader.hxx" #include "moon/mrb/texture.hxx" @@ -15,7 +8,14 @@ #include "moon/mrb/vector4.hxx" #include "moon/mrb/vertex_buffer.hxx" #include "moon/mrb_err.hxx" -#include "moon/mrb/helpers.hxx" +#include +#include +#include +#include +#include +#include +#include +#include static mrb_sym id_opacity; static mrb_sym id_tone; @@ -25,7 +25,8 @@ static mrb_sym id_oy; static mrb_sym id_angle; static mrb_sym id_transform; -struct RenderState { +struct RenderState +{ GLfloat opacity; GLfloat angle; Moon::Vector2 origin; @@ -33,19 +34,21 @@ struct RenderState { Moon::Vector4 tone; Moon::Matrix4 transform; - RenderState() : - opacity(1.0), - angle(0.0), - origin(0.0, 0.0), - color(1.0, 1.0, 1.0, 1.0), - tone(0.0, 0.0, 0.0, 1.0) {}; + RenderState() + : opacity(1.0) + , angle(0.0) + , origin(0.0, 0.0) + , color(1.0, 1.0, 1.0, 1.0) + , tone(0.0, 0.0, 0.0, 1.0){}; }; static mrb_value -spritesheet_generate_buffers(mrb_state *mrb, mrb_value self) +spritesheet_generate_buffers(mrb_state* mrb, mrb_value self) { - Moon::Texture *texture = mmrb_valid_texture_ptr(mrb, moon_iv_get(mrb, self, KEY_TEXTURE)); - Moon::VertexBuffer *vbo = mmrb_vertex_buffer_ptr(mrb, moon_iv_get(mrb, self, KEY_VBO)); + Moon::Texture* texture = + mmrb_valid_texture_ptr(mrb, moon_iv_get(mrb, self, KEY_TEXTURE)); + Moon::VertexBuffer* vbo = + mmrb_vertex_buffer_ptr(mrb, moon_iv_get(mrb, self, KEY_VBO)); const GLuint tile_width = mrb_int(mrb, moon_iv_get(mrb, self, "@w")); const GLuint tile_height = mrb_int(mrb, moon_iv_get(mrb, self, "@h")); const GLfloat tiles_per_row = texture->GetWidth() / tile_width; @@ -69,56 +72,57 @@ spritesheet_generate_buffers(mrb_state *mrb, mrb_value self) float t1 = (oy + 1.0) / tiles_per_column; Moon::Vertex vertices[4] = { - { {0.f, 0.f}, {s0, t0}, Moon::Vector4(1, 1, 1, 1) }, - { {tile_width, 0.f}, {s1, t0}, Moon::Vector4(1, 1, 1, 1) }, - { {tile_width, tile_height}, {s1, t1}, Moon::Vector4(1, 1, 1, 1) }, - { {0.f, tile_height}, {s0, t1}, Moon::Vector4(1, 1, 1, 1) } + { { 0.f, 0.f }, { s0, t0 }, Moon::Vector4(1, 1, 1, 1) }, + { { tile_width, 0.f }, { s1, t0 }, Moon::Vector4(1, 1, 1, 1) }, + { { tile_width, tile_height }, { s1, t1 }, Moon::Vector4(1, 1, 1, 1) }, + { { 0.f, tile_height }, { s0, t1 }, Moon::Vector4(1, 1, 1, 1) } }; vbo->PushBackVertices(vertices, 4); } - GLuint indices[4] = {0, 1, 3, 2}; + GLuint indices[4] = { 0, 1, 3, 2 }; vbo->PushBackIndices(indices, 4); return self; } static void -set_render_options(mrb_state *mrb, mrb_value options, RenderState *render_state) +set_render_options(mrb_state* mrb, mrb_value options, RenderState* render_state) { mrb_value keys = mrb_hash_keys(mrb, options); int len = mrb_ary_len(mrb, keys); - const mrb_value *keys_ary = RARRAY_PTR(keys); + const mrb_value* keys_ary = RARRAY_PTR(keys); for (int i = 0; i < len; ++i) { mrb_value key = keys_ary[i]; - if (!mrb_symbol_p(key)) continue; + if (!mrb_symbol_p(key)) + continue; mrb_value val = mrb_hash_get(mrb, options, key); // :opacity if (mrb_symbol(key) == id_opacity) { render_state->opacity = mrb_to_flo(mrb, val); - // :color + // :color } else if (mrb_symbol(key) == id_color) { render_state->color = mmrb_to_vector4(mrb, val); - // :tone + // :tone } else if (mrb_symbol(key) == id_tone) { render_state->tone = mmrb_to_vector4(mrb, val); - // :ox + // :ox } else if (mrb_symbol(key) == id_ox) { render_state->origin.x = mrb_to_flo(mrb, val); - // :oy + // :oy } else if (mrb_symbol(key) == id_oy) { render_state->origin.y = mrb_to_flo(mrb, val); - // :angle + // :angle } else if (mrb_symbol(key) == id_angle) { render_state->angle = mrb_to_flo(mrb, val); - // :transform + // :transform } else if (mrb_symbol(key) == id_transform) { render_state->transform = mmrb_to_matrix4(mrb, val); } @@ -126,22 +130,19 @@ set_render_options(mrb_state *mrb, mrb_value options, RenderState *render_state) } static mrb_value -spritesheet_copy_quad_to(mrb_state *mrb, mrb_value self) +spritesheet_copy_quad_to(mrb_state* mrb, mrb_value self) { RenderState render_state; - Moon::VertexBuffer *dest_vbo; - Moon::VertexBuffer *vbo; + Moon::VertexBuffer* dest_vbo; + Moon::VertexBuffer* vbo; mrb_float x, y, z; mrb_value options = mrb_nil_value(); mrb_int offset = 0; GLuint index; Moon::Vertex vertices[4]; GLuint indices[] = { 0, 1, 3, 2, 3, 1 }; - mrb_get_args(mrb, "dfffi|H", - &dest_vbo, &vbo_data_type, - &x, &y, &z, &offset, - &options - ); + mrb_get_args(mrb, "dfffi|H", &dest_vbo, &vbo_data_type, &x, &y, &z, &offset, + &options); if (!mrb_nil_p(options)) { set_render_options(mrb, options, &render_state); } @@ -162,19 +163,22 @@ spritesheet_copy_quad_to(mrb_state *mrb, mrb_value self) } MOON_C_API void -mmrb_spritesheet_init(mrb_state *mrb) +mmrb_spritesheet_init(mrb_state* mrb) { struct RClass* mod = mrb_define_module(mrb, "Moon"); - struct RClass *ss_cls = mrb_define_class_under(mrb, mod, "Spritesheet", mrb->object_class); - - mrb_define_method(mrb, ss_cls, "generate_buffers", spritesheet_generate_buffers, MRB_ARGS_NONE()); - mrb_define_method(mrb, ss_cls, "copy_quad_to", spritesheet_copy_quad_to, MRB_ARGS_ARG(5,1)); - - id_opacity = mrb_intern_cstr(mrb, "opacity"); - id_tone = mrb_intern_cstr(mrb, "tone"); - id_color = mrb_intern_cstr(mrb, "color"); - id_ox = mrb_intern_cstr(mrb, "ox"); - id_oy = mrb_intern_cstr(mrb, "oy"); - id_angle = mrb_intern_cstr(mrb, "angle"); + struct RClass* ss_cls = + mrb_define_class_under(mrb, mod, "Spritesheet", mrb->object_class); + + mrb_define_method(mrb, ss_cls, "generate_buffers", + spritesheet_generate_buffers, MRB_ARGS_NONE()); + mrb_define_method(mrb, ss_cls, "copy_quad_to", spritesheet_copy_quad_to, + MRB_ARGS_ARG(5, 1)); + + id_opacity = mrb_intern_cstr(mrb, "opacity"); + id_tone = mrb_intern_cstr(mrb, "tone"); + id_color = mrb_intern_cstr(mrb, "color"); + id_ox = mrb_intern_cstr(mrb, "ox"); + id_oy = mrb_intern_cstr(mrb, "oy"); + id_angle = mrb_intern_cstr(mrb, "angle"); id_transform = mrb_intern_cstr(mrb, "transform"); } diff --git a/modules/graphics/src/mrb_text.cxx b/modules/graphics/src/mrb_text.cxx index 3f433a1..969fe50 100644 --- a/modules/graphics/src/mrb_text.cxx +++ b/modules/graphics/src/mrb_text.cxx @@ -1,18 +1,18 @@ -#include -#include -#include -#include -#include -#include "moon/glm.h" #include "moon/api.h" #include "moon/font.hxx" -#include "moon/shader.hxx" -#include "moon/vertex_buffer.hxx" +#include "moon/glm.h" #include "moon/mrb/font.hxx" +#include "moon/mrb/helpers.hxx" #include "moon/mrb/shader.hxx" #include "moon/mrb/vector4.hxx" #include "moon/mrb/vertex_buffer.hxx" -#include "moon/mrb/helpers.hxx" +#include "moon/shader.hxx" +#include "moon/vertex_buffer.hxx" +#include +#include +#include +#include +#include /* Add a new text string to the VBO at the specified coordinates. * We use the coordinates to be able to generate alignment and layouts. @@ -22,18 +22,22 @@ * @param [Integer] y y coordinate */ static mrb_value -text_add_text(mrb_state *mrb, mrb_value self) +text_add_text(mrb_state* mrb, mrb_value self) { - char *str; + char* str; mrb_float x, y; mrb_get_args(mrb, "zff", &str, &x, &y); // string will be deleted at the end mrb_int outline = mrb_int(mrb, moon_iv_get(mrb, self, "@outline")); - mrb_float line_height = mrb_to_flo(mrb, moon_iv_get(mrb, self, "@line_height")); - Moon::VertexBuffer *vbo = mmrb_vertex_buffer_ptr(mrb, moon_iv_get(mrb, self, KEY_VBO)); - Moon::Font *font = mmrb_font_ptr(mrb, moon_iv_get(mrb, self, "@font")); - Moon::Vector4 color = *mmrb_vector4_ptr(mrb, moon_iv_get(mrb, self, "@color")); - Moon::Vector4 outline_color = *mmrb_vector4_ptr(mrb, moon_iv_get(mrb, self, "@outline_color")); + mrb_float line_height = + mrb_to_flo(mrb, moon_iv_get(mrb, self, "@line_height")); + Moon::VertexBuffer* vbo = + mmrb_vertex_buffer_ptr(mrb, moon_iv_get(mrb, self, KEY_VBO)); + Moon::Font* font = mmrb_font_ptr(mrb, moon_iv_get(mrb, self, "@font")); + Moon::Vector4 color = + *mmrb_vector4_ptr(mrb, moon_iv_get(mrb, self, "@color")); + Moon::Vector4 outline_color = + *mmrb_vector4_ptr(mrb, moon_iv_get(mrb, self, "@outline_color")); Moon::String string(str); if (outline > 0) { @@ -48,10 +52,11 @@ text_add_text(mrb_state *mrb, mrb_value self) } MOON_C_API void -mmrb_text_init(mrb_state *mrb) +mmrb_text_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *text_cls = mrb_define_class_under(mrb, mod, "Text", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* text_cls = + mrb_define_class_under(mrb, mod, "Text", mrb->object_class); mrb_define_method(mrb, text_cls, "add_text", text_add_text, MRB_ARGS_REQ(3)); } diff --git a/modules/graphics/src/mrb_texture.cxx b/modules/graphics/src/mrb_texture.cxx index 6e3ced6..5fc9609 100644 --- a/modules/graphics/src/mrb_texture.cxx +++ b/modules/graphics/src/mrb_texture.cxx @@ -1,25 +1,26 @@ +#include "moon/api.h" +#include "moon/mrb/texture.hxx" +#include "moon/texture.hxx" #include #include #include #include #include -#include "moon/mrb/texture.hxx" -#include "moon/texture.hxx" -#include "moon/api.h" static void -texture_free(mrb_state *mrb, void *p) +texture_free(mrb_state* mrb, void* p) { - Moon::Texture *texture = (Moon::Texture*)p; + Moon::Texture* texture = (Moon::Texture*)p; if (texture) { - delete(texture); + delete (texture); } } -MOON_C_API const struct mrb_data_type texture_data_type = { "Texture", texture_free }; +MOON_C_API const struct mrb_data_type texture_data_type = { "Texture", + texture_free }; MOON_C_API mrb_value -mmrb_texture_load_file(mrb_state *mrb, const char *filename) +mmrb_texture_load_file(mrb_state* mrb, const char* filename) { mrb_value fn = mrb_str_new_cstr(mrb, filename); return mrb_obj_new(mrb, mmrb_get_texture_class(mrb), 1, &fn); @@ -29,10 +30,10 @@ mmrb_texture_load_file(mrb_state *mrb, const char *filename) * @return [Texture] */ static mrb_value -texture_initialize(mrb_state *mrb, mrb_value self) +texture_initialize(mrb_state* mrb, mrb_value self) { char* filename; - Moon::Texture *texture; + Moon::Texture* texture; mrb_get_args(mrb, "z", &filename); texture = (Moon::Texture*)DATA_PTR(self); @@ -45,28 +46,27 @@ texture_initialize(mrb_state *mrb, mrb_value self) if (exists(filename)) { texture = new Moon::Texture(filename); } else { - mrb_raisef(mrb, E_SCRIPT_ERROR, - "cannot load such file -- %S", + mrb_raisef(mrb, E_SCRIPT_ERROR, "cannot load such file -- %S", mrb_str_new_cstr(mrb, filename)); } mrb_data_init(self, texture, &texture_data_type); return self; } -/* +/* * @return [Float] width of the texture */ static mrb_value -texture_width(mrb_state *mrb, mrb_value self) +texture_width(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_texture_ptr(mrb, self)->GetWidth()); } -/* +/* * @return [Float] height of the texture */ static mrb_value -texture_height(mrb_state *mrb, mrb_value self) +texture_height(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_texture_ptr(mrb, self)->GetHeight()); } @@ -76,7 +76,7 @@ texture_height(mrb_state *mrb, mrb_value self) * @return [Integer] intenal id of the texture */ static mrb_value -texture_id(mrb_state *mrb, mrb_value self) +texture_id(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_texture_ptr(mrb, self)->GetID()); } @@ -87,23 +87,25 @@ texture_id(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -texture_bind(mrb_state *mrb, mrb_value self) +texture_bind(mrb_state* mrb, mrb_value self) { mmrb_texture_ptr(mrb, self)->Bind(); return self; } MOON_C_API void -mmrb_texture_init(mrb_state *mrb) +mmrb_texture_init(mrb_state* mrb) { struct RClass* mod = mrb_define_module(mrb, "Moon"); // A storage class for pixel data on the GPU. - struct RClass *texture_class = mrb_define_class_under(mrb, mod, "Texture", mrb->object_class); + struct RClass* texture_class = + mrb_define_class_under(mrb, mod, "Texture", mrb->object_class); MRB_SET_INSTANCE_TT(texture_class, MRB_TT_DATA); - mrb_define_method(mrb, texture_class, "initialize", texture_initialize, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, texture_class, "w", texture_width, MRB_ARGS_NONE()); - mrb_define_method(mrb, texture_class, "h", texture_height, MRB_ARGS_NONE()); - mrb_define_method(mrb, texture_class, "id", texture_id, MRB_ARGS_NONE()); - mrb_define_method(mrb, texture_class, "bind", texture_bind, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "initialize", texture_initialize, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, texture_class, "w", texture_width, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "h", texture_height, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "id", texture_id, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "bind", texture_bind, MRB_ARGS_NONE()); } diff --git a/modules/graphics/src/mrb_vertex_buffer.cxx b/modules/graphics/src/mrb_vertex_buffer.cxx index 13d5089..b91ef81 100644 --- a/modules/graphics/src/mrb_vertex_buffer.cxx +++ b/modules/graphics/src/mrb_vertex_buffer.cxx @@ -1,27 +1,28 @@ -#include -#include -#include -#include -#include +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" #include "moon/mrb/rect.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" #include "moon/mrb/vertex_buffer.hxx" -#include "moon/mrb/helpers.hxx" #include "moon/vertex_buffer.hxx" -#include "moon/api.h" +#include +#include +#include +#include +#include static void -vbo_free(mrb_state *mrb, void *p) +vbo_free(mrb_state* mrb, void* p) { - Moon::VertexBuffer *vbo = (Moon::VertexBuffer*)p; + Moon::VertexBuffer* vbo = (Moon::VertexBuffer*)p; if (vbo) { - delete(vbo); + delete (vbo); } } -MOON_C_API const struct mrb_data_type vbo_data_type = { "Moon::VertexBuffer", vbo_free }; +MOON_C_API const struct mrb_data_type vbo_data_type = { "Moon::VertexBuffer", + vbo_free }; /* Creates a new buffer to store vertex and index data on the GPU. * @param [Integer] usage Intended usage mode that hints to OpenGL on how to @@ -30,10 +31,10 @@ MOON_C_API const struct mrb_data_type vbo_data_type = { "Moon::VertexBuffer", vb * @return [VertexBuffer] */ static mrb_value -vbo_initialize(mrb_state *mrb, mrb_value self) +vbo_initialize(mrb_state* mrb, mrb_value self) { GLenum usage; - Moon::VertexBuffer *vbo; + Moon::VertexBuffer* vbo; mrb_get_args(mrb, "i", &usage); vbo_free(mrb, DATA_PTR(self)); @@ -49,7 +50,7 @@ vbo_initialize(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -vbo_clear(mrb_state *mrb, mrb_value self) +vbo_clear(mrb_state* mrb, mrb_value self) { mmrb_vertex_buffer_ptr(mrb, self)->Clear(); return self; @@ -69,7 +70,7 @@ vbo_clear(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -vbo_render(mrb_state *mrb, mrb_value self) +vbo_render(mrb_state* mrb, mrb_value self) { GLenum mode; GLuint offset; @@ -89,17 +90,15 @@ vbo_render(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -vbo_push_back(mrb_state *mrb, mrb_value self) +vbo_push_back(mrb_state* mrb, mrb_value self) { - Moon::Vector2 *pos; - Moon::Vector2 *tex_coord; - Moon::Vector4 *color; - mrb_get_args(mrb, "ddd", - &pos, &vbo_data_type, - &tex_coord, &vbo_data_type, - &color, &vbo_data_type - ); - mmrb_vertex_buffer_ptr(mrb, self)->PushBack(Moon::Vertex(*pos, *tex_coord, *color)); + Moon::Vector2* pos; + Moon::Vector2* tex_coord; + Moon::Vector4* color; + mrb_get_args(mrb, "ddd", &pos, &vbo_data_type, &tex_coord, &vbo_data_type, + &color, &vbo_data_type); + mmrb_vertex_buffer_ptr(mrb, self)->PushBack( + Moon::Vertex(*pos, *tex_coord, *color)); return self; } @@ -110,10 +109,10 @@ vbo_push_back(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -vbo_push_indices(mrb_state *mrb, mrb_value self) +vbo_push_indices(mrb_state* mrb, mrb_value self) { mrb_int length; - mrb_value *indices; + mrb_value* indices; mrb_get_args(mrb, "a", &indices, &length); // hell no, am I gonna malloc an array for this just to push it at once. // its a bit ugly to be resizing it each time though... @@ -127,7 +126,7 @@ vbo_push_indices(mrb_state *mrb, mrb_value self) /* @return [Integer] Returns the number of VBO vertices stored in the buffer. */ static mrb_value -vbo_vertex_count(mrb_state *mrb, mrb_value self) +vbo_vertex_count(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_vertex_buffer_ptr(mrb, self)->GetVertexCount()); } @@ -135,13 +134,14 @@ vbo_vertex_count(mrb_state *mrb, mrb_value self) /* @return [Integer] Returns the number of IBO indices stored in the buffer. */ static mrb_value -vbo_index_count(mrb_state *mrb, mrb_value self) +vbo_index_count(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_vertex_buffer_ptr(mrb, self)->GetIndexCount()); } static void -make_quad(Moon::Vertex vertices[4], Moon::IntRect& quad_rect, Moon::FloatRect& quad_texture_rect, Moon::Vector4& color) +make_quad(Moon::Vertex vertices[4], Moon::IntRect& quad_rect, + Moon::FloatRect& quad_texture_rect, Moon::Vector4& color) { GLfloat x0, x1, y0, y1; GLfloat tx0, tx1, ty0, ty1; @@ -163,7 +163,7 @@ make_quad(Moon::Vertex vertices[4], Moon::IntRect& quad_rect, Moon::FloatRect& q } static void -vbo_quad_m(mrb_state *mrb, mrb_value self, Moon::Vertex vertices[4]) +vbo_quad_m(mrb_state* mrb, mrb_value self, Moon::Vertex vertices[4]) { Moon::IntRect quad_rect; Moon::FloatRect quad_texture_rect; @@ -182,11 +182,11 @@ vbo_quad_m(mrb_state *mrb, mrb_value self, Moon::Vertex vertices[4]) } static mrb_value -vbo_add_quad(mrb_state *mrb, mrb_value self) +vbo_add_quad(mrb_state* mrb, mrb_value self) { Moon::Vertex vertices[4]; GLuint indices[] = { 0, 1, 3, 2, 3, 1 }; - Moon::VertexBuffer *vbo = NULL; + Moon::VertexBuffer* vbo = NULL; vbo_quad_m(mrb, self, vertices); vbo = mmrb_vertex_buffer_ptr(mrb, self); vbo->PushBack(vertices, 4, indices, 6); @@ -194,10 +194,10 @@ vbo_add_quad(mrb_state *mrb, mrb_value self) } static mrb_value -vbo_add_quad_vertices(mrb_state *mrb, mrb_value self) +vbo_add_quad_vertices(mrb_state* mrb, mrb_value self) { Moon::Vertex vertices[4]; - Moon::VertexBuffer *vbo = NULL; + Moon::VertexBuffer* vbo = NULL; vbo_quad_m(mrb, self, vertices); vbo = mmrb_vertex_buffer_ptr(mrb, self); vbo->PushBackVertices(vertices, 4); @@ -205,19 +205,27 @@ vbo_add_quad_vertices(mrb_state *mrb, mrb_value self) } MOON_C_API void -mmrb_vbo_init(mrb_state *mrb) +mmrb_vbo_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *vbo_class = mrb_define_class_under(mrb, mod, "VertexBuffer", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* vbo_class = + mrb_define_class_under(mrb, mod, "VertexBuffer", mrb->object_class); MRB_SET_INSTANCE_TT(vbo_class, MRB_TT_DATA); - mrb_define_method(mrb, vbo_class, "initialize", vbo_initialize, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vbo_class, "clear", vbo_clear, MRB_ARGS_NONE()); - mrb_define_method(mrb, vbo_class, "render", vbo_render, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1)); - mrb_define_method(mrb, vbo_class, "push_back", vbo_push_back, MRB_ARGS_REQ(3)); - mrb_define_method(mrb, vbo_class, "push_indices", vbo_push_indices, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vbo_class, "vertex_count", vbo_vertex_count, MRB_ARGS_NONE()); - mrb_define_method(mrb, vbo_class, "index_count", vbo_index_count, MRB_ARGS_NONE()); - mrb_define_method(mrb, vbo_class, "add_quad", vbo_add_quad, MRB_ARGS_REQ(3)); - mrb_define_method(mrb, vbo_class, "add_quad_vertices", vbo_add_quad_vertices, MRB_ARGS_REQ(3)); + mrb_define_method(mrb, vbo_class, "initialize", vbo_initialize, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vbo_class, "clear", vbo_clear, MRB_ARGS_NONE()); + mrb_define_method(mrb, vbo_class, "render", vbo_render, + MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1)); + mrb_define_method(mrb, vbo_class, "push_back", vbo_push_back, + MRB_ARGS_REQ(3)); + mrb_define_method(mrb, vbo_class, "push_indices", vbo_push_indices, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vbo_class, "vertex_count", vbo_vertex_count, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vbo_class, "index_count", vbo_index_count, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vbo_class, "add_quad", vbo_add_quad, MRB_ARGS_REQ(3)); + mrb_define_method(mrb, vbo_class, "add_quad_vertices", vbo_add_quad_vertices, + MRB_ARGS_REQ(3)); } diff --git a/modules/graphics/src/shader.cxx b/modules/graphics/src/shader.cxx index 2e869bf..82e3209 100644 --- a/modules/graphics/src/shader.cxx +++ b/modules/graphics/src/shader.cxx @@ -1,167 +1,205 @@ -#include #include "moon/shader.hxx" +#include namespace Moon { - bool Shader::is_legacy = false; - - Shader::Shader(const std::string vertexShader, const std::string fragmentShader) { - m_program = CreateProgram(vertexShader, fragmentShader); - }; - - Shader::~Shader() { - glDeleteProgram(m_program); - }; - - /** - * Display compilation errors from the OpenGL shader compiler - */ - void Shader::PrintLog(GLuint object) { - GLint infoLogLength = 0; - if (glIsShader(object)) - glGetShaderiv(object, GL_INFO_LOG_LENGTH, &infoLogLength); - else if (glIsProgram(object)) - glGetProgramiv(object, GL_INFO_LOG_LENGTH, &infoLogLength); - else { - std::cerr << "Shader: Not a shader or program" << std::endl; - return; - } - - GLchar *infoLog = new GLchar[infoLogLength]; - - if (glIsShader(object)) - glGetShaderInfoLog(object, infoLogLength, NULL, infoLog); - else if (glIsProgram(object)) - glGetProgramInfoLog(object, infoLogLength, NULL, infoLog); - - fprintf(stderr, "%s", infoLog); - delete [] infoLog; - } - - /** - * Compile the shader from file 'filename', with error handling - */ - GLuint Shader::CreateShader(const std::string contents, GLenum type) { - const GLchar* source = contents.c_str(); - GLuint res = glCreateShader(type); - glShaderSource(res, 1, &source, NULL); - - glCompileShader(res); - GLint status; - glGetShaderiv(res, GL_COMPILE_STATUS, &status); - if (status == GL_FALSE) { - fprintf(stderr, "Shader::CreateShader(_, %i) error occured:", type); - PrintLog(res); - glDeleteShader(res); - return 0; - } - - return res; - } - - GLuint Shader::CreateProgram(const std::string vertexContent, const std::string fragmentContent) { - GLuint shader; - GLuint program = glCreateProgram(); - assert(program); - - shader = CreateShader(vertexContent, GL_VERTEX_SHADER); - if (!shader) return 0; - glAttachShader(program, shader); - glDeleteShader(shader); // http://stackoverflow.com/questions/9113154/proper-way-to-delete-glsl-shader - - shader = CreateShader(fragmentContent, GL_FRAGMENT_SHADER); - if(!shader) return 0; - glAttachShader(program, shader); - glDeleteShader(shader); - - if (Shader::is_legacy) { - glBindAttribLocation(program, 0, "vertex_pos"); - glBindAttribLocation(program, 1, "texcoord"); - glBindAttribLocation(program, 2, "color"); - } - - glLinkProgram(program); - GLint status; - glGetProgramiv(program, GL_LINK_STATUS, &status); - if (!status) { - fprintf(stderr, "glLinkProgram:"); - PrintLog(program); - glDeleteProgram(program); - return 0; - } - - return program; - } - - GLint Shader::InitAttribute(std::string name) { - GLint attribute = glGetAttribLocation(m_program, name.c_str()); - if (attribute == -1) { - fprintf(stderr, "Shader(program_id: %i): OpenGL Error 0x%04x: Could not bind attribute %s\n", m_program, glGetError(), name.c_str()); - abort(); - } - m_attributeList[name] = attribute; - return attribute; - } +bool Shader::is_legacy = false; - GLint Shader::InitUniform(std::string name) { - GLint uniform = glGetUniformLocation(m_program, name.c_str()); - if (uniform == -1) { - fprintf(stderr, "Shader(program_id: %i): OpenGL Error 0x%04x: Could not bind uniform %s\n", m_program, glGetError(), name.c_str()); - abort(); - } - m_uniformLocationList[name] = uniform; - return uniform; - } +Shader::Shader(const std::string vertexShader, const std::string fragmentShader) +{ + m_program = CreateProgram(vertexShader, fragmentShader); +}; - GLint Shader::Attribute(std::string name) { - assert(m_program); - AttributeMap::iterator iter = m_attributeList.find(name); - if (iter == m_attributeList.end()) { - return InitAttribute(name); - } else { - return iter->second; - } - } +Shader::~Shader() +{ + glDeleteProgram(m_program); +}; - GLint Shader::Uniform(std::string name) { - assert(m_program); - AttributeMap::iterator iter = m_uniformLocationList.find(name); - if (iter == m_uniformLocationList.end()) { - return InitUniform(name); - } else { - return iter->second; - } +/** + * Display compilation errors from the OpenGL shader compiler + */ +void +Shader::PrintLog(GLuint object) +{ + GLint infoLogLength = 0; + if (glIsShader(object)) + glGetShaderiv(object, GL_INFO_LOG_LENGTH, &infoLogLength); + else if (glIsProgram(object)) + glGetProgramiv(object, GL_INFO_LOG_LENGTH, &infoLogLength); + else { + std::cerr << "Shader: Not a shader or program" << std::endl; + return; } - void Shader::SetUniform(std::string name, const GLint v1) { - glUniform1i(Uniform(name), v1); + GLchar* infoLog = new GLchar[infoLogLength]; + + if (glIsShader(object)) + glGetShaderInfoLog(object, infoLogLength, NULL, infoLog); + else if (glIsProgram(object)) + glGetProgramInfoLog(object, infoLogLength, NULL, infoLog); + + fprintf(stderr, "%s", infoLog); + delete[] infoLog; +} + +/** + * Compile the shader from file 'filename', with error handling + */ +GLuint +Shader::CreateShader(const std::string contents, GLenum type) +{ + const GLchar* source = contents.c_str(); + GLuint res = glCreateShader(type); + glShaderSource(res, 1, &source, NULL); + + glCompileShader(res); + GLint status; + glGetShaderiv(res, GL_COMPILE_STATUS, &status); + if (status == GL_FALSE) { + fprintf(stderr, "Shader::CreateShader(_, %i) error occured:", type); + PrintLog(res); + glDeleteShader(res); + return 0; } - void Shader::SetUniform(std::string name, const GLfloat v1) { - glUniform1f(Uniform(name), v1); + return res; +} + +GLuint +Shader::CreateProgram(const std::string vertexContent, + const std::string fragmentContent) +{ + GLuint shader; + GLuint program = glCreateProgram(); + assert(program); + + shader = CreateShader(vertexContent, GL_VERTEX_SHADER); + if (!shader) + return 0; + glAttachShader(program, shader); + glDeleteShader( + shader); // http://stackoverflow.com/questions/9113154/proper-way-to-delete-glsl-shader + + shader = CreateShader(fragmentContent, GL_FRAGMENT_SHADER); + if (!shader) + return 0; + glAttachShader(program, shader); + glDeleteShader(shader); + + if (Shader::is_legacy) { + glBindAttribLocation(program, 0, "vertex_pos"); + glBindAttribLocation(program, 1, "texcoord"); + glBindAttribLocation(program, 2, "color"); } - //void Shader::SetUniform(std::string name, const Moon::Vector1 &vec) { - // glUniform1fv(Uniform(name), 1, glm::value_ptr(vec)); - //} - - void Shader::SetUniform(std::string name, const Moon::Vector2 &vec) { - glUniform2fv(Uniform(name), 1, glm::value_ptr(vec)); + glLinkProgram(program); + GLint status; + glGetProgramiv(program, GL_LINK_STATUS, &status); + if (!status) { + fprintf(stderr, "glLinkProgram:"); + PrintLog(program); + glDeleteProgram(program); + return 0; } - void Shader::SetUniform(std::string name, const Moon::Vector3 &vec) { - glUniform3fv(Uniform(name), 1, glm::value_ptr(vec)); + return program; +} + +GLint +Shader::InitAttribute(std::string name) +{ + GLint attribute = glGetAttribLocation(m_program, name.c_str()); + if (attribute == -1) { + fprintf(stderr, "Shader(program_id: %i): OpenGL Error 0x%04x: Could not " + "bind attribute %s\n", + m_program, glGetError(), name.c_str()); + abort(); } - - void Shader::SetUniform(std::string name, const Moon::Vector4 &vec) { - glUniform4fv(Uniform(name), 1, glm::value_ptr(vec)); + m_attributeList[name] = attribute; + return attribute; +} + +GLint +Shader::InitUniform(std::string name) +{ + GLint uniform = glGetUniformLocation(m_program, name.c_str()); + if (uniform == -1) { + fprintf(stderr, "Shader(program_id: %i): OpenGL Error 0x%04x: Could not " + "bind uniform %s\n", + m_program, glGetError(), name.c_str()); + abort(); } - - void Shader::SetUniform(std::string name, const Moon::Matrix4 &mat) { - glUniformMatrix4fv(Uniform(name), 1, GL_FALSE, glm::value_ptr(mat)); + m_uniformLocationList[name] = uniform; + return uniform; +} + +GLint +Shader::Attribute(std::string name) +{ + assert(m_program); + AttributeMap::iterator iter = m_attributeList.find(name); + if (iter == m_attributeList.end()) { + return InitAttribute(name); + } else { + return iter->second; } - - void Shader::Use() { - assert(m_program); - glUseProgram(m_program); +} + +GLint +Shader::Uniform(std::string name) +{ + assert(m_program); + AttributeMap::iterator iter = m_uniformLocationList.find(name); + if (iter == m_uniformLocationList.end()) { + return InitUniform(name); + } else { + return iter->second; } +} + +void +Shader::SetUniform(std::string name, const GLint v1) +{ + glUniform1i(Uniform(name), v1); +} + +void +Shader::SetUniform(std::string name, const GLfloat v1) +{ + glUniform1f(Uniform(name), v1); +} + +// void Shader::SetUniform(std::string name, const Moon::Vector1 &vec) { +// glUniform1fv(Uniform(name), 1, glm::value_ptr(vec)); +//} + +void +Shader::SetUniform(std::string name, const Moon::Vector2& vec) +{ + glUniform2fv(Uniform(name), 1, glm::value_ptr(vec)); +} + +void +Shader::SetUniform(std::string name, const Moon::Vector3& vec) +{ + glUniform3fv(Uniform(name), 1, glm::value_ptr(vec)); +} + +void +Shader::SetUniform(std::string name, const Moon::Vector4& vec) +{ + glUniform4fv(Uniform(name), 1, glm::value_ptr(vec)); +} + +void +Shader::SetUniform(std::string name, const Moon::Matrix4& mat) +{ + glUniformMatrix4fv(Uniform(name), 1, GL_FALSE, glm::value_ptr(mat)); +} + +void +Shader::Use() +{ + assert(m_program); + glUseProgram(m_program); +} }; diff --git a/modules/graphics/src/texture.cxx b/modules/graphics/src/texture.cxx index b5e40c0..4f44811 100644 --- a/modules/graphics/src/texture.cxx +++ b/modules/graphics/src/texture.cxx @@ -1,47 +1,59 @@ -#include #include "moon/texture.hxx" #include "moon/gl.h" +#include namespace Moon { - Texture::Texture(std::string filename) - { - unsigned char* pixels; - int channels; - float border_color[4] = { 0.0, 0.0, 0.0, 0.0 }; - - pixels = SOIL_load_image(filename.c_str(), &m_width, &m_height, &channels, SOIL_LOAD_AUTO); - m_gl_texture_id = SOIL_create_OGL_texture(pixels, m_width, m_height, channels, SOIL_CREATE_NEW_ID, SOIL_FLAG_MULTIPLY_ALPHA); - SOIL_free_image_data(pixels); - - glBindTexture(GL_TEXTURE_2D, m_gl_texture_id); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color); - glBindTexture(GL_TEXTURE_2D, 0); - }; - - Texture::~Texture() { - //Delete texture - if (m_gl_texture_id != 0) { - glDeleteTextures(1, &m_gl_texture_id); - } - }; - - GLint Texture::GetWidth() { - return m_width; - }; - - GLint Texture::GetHeight() { - return m_height; - }; - - GLuint Texture::GetID() { - return m_gl_texture_id; - }; - - void Texture::Bind() { - glBindTexture(GL_TEXTURE_2D, m_gl_texture_id); - }; +Texture::Texture(std::string filename) +{ + unsigned char* pixels; + int channels; + float border_color[4] = { 0.0, 0.0, 0.0, 0.0 }; + + pixels = SOIL_load_image(filename.c_str(), &m_width, &m_height, &channels, + SOIL_LOAD_AUTO); + m_gl_texture_id = + SOIL_create_OGL_texture(pixels, m_width, m_height, channels, + SOIL_CREATE_NEW_ID, SOIL_FLAG_MULTIPLY_ALPHA); + SOIL_free_image_data(pixels); + + glBindTexture(GL_TEXTURE_2D, m_gl_texture_id); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color); + glBindTexture(GL_TEXTURE_2D, 0); +}; + +Texture::~Texture() +{ + // Delete texture + if (m_gl_texture_id != 0) { + glDeleteTextures(1, &m_gl_texture_id); + } +}; + +GLint +Texture::GetWidth() +{ + return m_width; +}; + +GLint +Texture::GetHeight() +{ + return m_height; +}; + +GLuint +Texture::GetID() +{ + return m_gl_texture_id; +}; + +void +Texture::Bind() +{ + glBindTexture(GL_TEXTURE_2D, m_gl_texture_id); +}; } diff --git a/modules/graphics/src/vertex_buffer.cxx b/modules/graphics/src/vertex_buffer.cxx index 0282380..21743e0 100644 --- a/modules/graphics/src/vertex_buffer.cxx +++ b/modules/graphics/src/vertex_buffer.cxx @@ -3,143 +3,176 @@ #include "moon/glm.h" namespace Moon { - VertexBuffer::VertexBuffer(GLenum usage) { - m_usage = usage; - glGenVertexArrays(1, &m_vao_id); - glGenBuffers(1, &m_vbo_id); - glGenBuffers(1, &m_ibo_id); - m_dirty = false; - Setup(); - } - - VertexBuffer::~VertexBuffer() { - glDeleteVertexArrays(1, &m_vao_id); - glDeleteBuffers(1, &m_vbo_id); - glDeleteBuffers(1, &m_ibo_id); - } - - void VertexBuffer::Setup() { - glBindVertexArray(m_vao_id); - - //Enable vertex and texture coordinate arrays - glEnableVertexAttribArray(0); // location=0 --> vertex position - glEnableVertexAttribArray(1); // location=1 --> texture coordinates - glEnableVertexAttribArray(2); // location=2 --> color - - // Bind vertex buffer and index buffer - glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id); - - glVertexAttribPointer( - 0, // attribute - 2, // number of elements per vertex, here (x,y) - GL_FLOAT, // the type of each element - GL_FALSE, // take our values as-is - sizeof(Vertex), // stride - (GLvoid*)offsetof(Vertex, pos) // offset of first element +VertexBuffer::VertexBuffer(GLenum usage) +{ + m_usage = usage; + glGenVertexArrays(1, &m_vao_id); + glGenBuffers(1, &m_vbo_id); + glGenBuffers(1, &m_ibo_id); + m_dirty = false; + Setup(); +} + +VertexBuffer::~VertexBuffer() +{ + glDeleteVertexArrays(1, &m_vao_id); + glDeleteBuffers(1, &m_vbo_id); + glDeleteBuffers(1, &m_ibo_id); +} + +void +VertexBuffer::Setup() +{ + glBindVertexArray(m_vao_id); + + // Enable vertex and texture coordinate arrays + glEnableVertexAttribArray(0); // location=0 --> vertex position + glEnableVertexAttribArray(1); // location=1 --> texture coordinates + glEnableVertexAttribArray(2); // location=2 --> color + + // Bind vertex buffer and index buffer + glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id); + + glVertexAttribPointer( + 0, // attribute + 2, // number of elements per vertex, here (x,y) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + sizeof(Vertex), // stride + (GLvoid*)offsetof(Vertex, pos) // offset of first element ); - glVertexAttribPointer( - 1, // attribute - 2, // number of elements per vertex, here (x,y) - GL_FLOAT, // the type of each element - GL_FALSE, // take our values as-is - sizeof(Vertex), // stride - (GLvoid*)offsetof(Vertex, tex_coord) // offset of first element + glVertexAttribPointer( + 1, // attribute + 2, // number of elements per vertex, here (x,y) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + sizeof(Vertex), // stride + (GLvoid*)offsetof(Vertex, tex_coord) // offset of first element ); - glVertexAttribPointer( - 2, // attribute - 4, // number of elements per vertex, here (x,y) - GL_FLOAT, // the type of each element - GL_FALSE, // take our values as-is - sizeof(Vertex), // stride - (GLvoid*)offsetof(Vertex, color) // offset of first element + glVertexAttribPointer( + 2, // attribute + 4, // number of elements per vertex, here (x,y) + GL_FLOAT, // the type of each element + GL_FALSE, // take our values as-is + sizeof(Vertex), // stride + (GLvoid*)offsetof(Vertex, color) // offset of first element ); - glBindVertexArray(0); - }; - - void VertexBuffer::PushBack(Vertex v) { - m_vertices.push_back(v); - m_indices.push_back(m_indices.size()); - m_dirty = true; - } - - void VertexBuffer::PushBackVertices(Vertex *v, int vertex_count) { - m_vertices.reserve(vertex_count); - std::copy(v, v+vertex_count, std::back_inserter(m_vertices)); - m_dirty = true; - } - - void VertexBuffer::PushBackIndices(GLuint i[], int index_count) { - m_indices.reserve(index_count); - std::copy(i, i+index_count, std::back_inserter(m_indices)); - m_dirty = true; - } - - void VertexBuffer::PushBack(Vertex *v, int vertex_count, GLuint i[], int index_count) { - int size = m_vertices.size(); - PushBackVertices(v, vertex_count); - PushBackIndices(i, index_count); - // update the indices we've just copied over, since the old values - // were something like (0,1,2,3) - relative to the vertex that was - // pushed, and we want them to be set on a global range. - std::transform(m_indices.end()-index_count, m_indices.end(), m_indices.end()-index_count, - std::bind2nd(std::plus(), size)); - m_dirty = true; - } - - GLuint VertexBuffer::GetVertexCount() { - return m_vertices.size(); - } - - GLuint VertexBuffer::GetIndexCount() { - return m_indices.size(); - } - - Vertex VertexBuffer::GetVertex(const int index) { - // we should probably handle errors more graciously... - assert(index < (int)m_vertices.size()); - assert(index >= 0); - return m_vertices[index]; - } - - GLuint VertexBuffer::GetIndex(const int index) { - // we should probably handle errors more graciously... - assert(index < (int)m_indices.size()); - assert(index >= 0); - return m_indices[index]; - } - - void VertexBuffer::Clear() { - m_vertices.clear(); - m_indices.clear(); - Upload(); - } - - // upload the buffer to the GPU - void VertexBuffer::Upload() { - glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); - glBufferData(GL_ARRAY_BUFFER, m_vertices.size() * sizeof(Vertex), &m_vertices.front(), m_usage); - - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id); - glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices.size() * sizeof(GLuint), &m_indices.front(), m_usage); - m_dirty = false; - } - - void VertexBuffer::Render(GLenum mode) { - /*if (m_dirty) Upload(); // update the VBO and IBO if dirty - glBindVertexArray(m_vao_id); - glDrawElements(mode, m_indices.size(), GL_UNSIGNED_INT, NULL); - glBindVertexArray(0);*/ - Render(mode, 0); - } - - void VertexBuffer::Render(GLenum mode, const int offset) { - if (m_dirty) Upload(); // update the VBO and IBO if dirty - glBindVertexArray(m_vao_id); - glDrawElementsBaseVertex(mode, m_indices.size(), GL_UNSIGNED_INT, NULL, offset); - glBindVertexArray(0); - } + glBindVertexArray(0); +}; + +void +VertexBuffer::PushBack(Vertex v) +{ + m_vertices.push_back(v); + m_indices.push_back(m_indices.size()); + m_dirty = true; +} + +void +VertexBuffer::PushBackVertices(Vertex* v, int vertex_count) +{ + m_vertices.reserve(vertex_count); + std::copy(v, v + vertex_count, std::back_inserter(m_vertices)); + m_dirty = true; +} + +void +VertexBuffer::PushBackIndices(GLuint i[], int index_count) +{ + m_indices.reserve(index_count); + std::copy(i, i + index_count, std::back_inserter(m_indices)); + m_dirty = true; +} + +void +VertexBuffer::PushBack(Vertex* v, int vertex_count, GLuint i[], int index_count) +{ + int size = m_vertices.size(); + PushBackVertices(v, vertex_count); + PushBackIndices(i, index_count); + // update the indices we've just copied over, since the old values + // were something like (0,1,2,3) - relative to the vertex that was + // pushed, and we want them to be set on a global range. + std::transform(m_indices.end() - index_count, m_indices.end(), + m_indices.end() - index_count, + std::bind2nd(std::plus(), size)); + m_dirty = true; +} + +GLuint +VertexBuffer::GetVertexCount() +{ + return m_vertices.size(); +} + +GLuint +VertexBuffer::GetIndexCount() +{ + return m_indices.size(); +} + +Vertex +VertexBuffer::GetVertex(const int index) +{ + // we should probably handle errors more graciously... + assert(index < (int)m_vertices.size()); + assert(index >= 0); + return m_vertices[index]; +} + +GLuint +VertexBuffer::GetIndex(const int index) +{ + // we should probably handle errors more graciously... + assert(index < (int)m_indices.size()); + assert(index >= 0); + return m_indices[index]; +} + +void +VertexBuffer::Clear() +{ + m_vertices.clear(); + m_indices.clear(); + Upload(); +} + +// upload the buffer to the GPU +void +VertexBuffer::Upload() +{ + glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); + glBufferData(GL_ARRAY_BUFFER, m_vertices.size() * sizeof(Vertex), + &m_vertices.front(), m_usage); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices.size() * sizeof(GLuint), + &m_indices.front(), m_usage); + m_dirty = false; +} + +void +VertexBuffer::Render(GLenum mode) +{ + /*if (m_dirty) Upload(); // update the VBO and IBO if dirty + glBindVertexArray(m_vao_id); + glDrawElements(mode, m_indices.size(), GL_UNSIGNED_INT, NULL); + glBindVertexArray(0);*/ + Render(mode, 0); +} + +void +VertexBuffer::Render(GLenum mode, const int offset) +{ + if (m_dirty) + Upload(); // update the VBO and IBO if dirty + glBindVertexArray(m_vao_id); + glDrawElementsBaseVertex(mode, m_indices.size(), GL_UNSIGNED_INT, NULL, + offset); + glBindVertexArray(0); +} } diff --git a/modules/system/include/moon/fps.hxx b/modules/system/include/moon/fps.hxx index 63c3f47..af3cd9d 100644 --- a/modules/system/include/moon/fps.hxx +++ b/modules/system/include/moon/fps.hxx @@ -2,21 +2,23 @@ #define MOON_FPS_H namespace Moon { - class FPS { - public: - FPS(); +class FPS +{ +public: + FPS(); - int GetFPS(); - float GetDelta(); - void Update(); - float Restart(); - private: - float m_old_time; - float m_last_time; - float m_delta; // time since last frame - int m_fps; - int m_frames; - }; + int GetFPS(); + float GetDelta(); + void Update(); + float Restart(); + +private: + float m_old_time; + float m_last_time; + float m_delta; // time since last frame + int m_fps; + int m_frames; +}; }; #endif diff --git a/modules/system/include/moon/matrix4.hxx b/modules/system/include/moon/matrix4.hxx index 5e15c25..44d69d2 100644 --- a/modules/system/include/moon/matrix4.hxx +++ b/modules/system/include/moon/matrix4.hxx @@ -4,7 +4,7 @@ #include "moon/glm.h" namespace Moon { - typedef glm::mat4 Matrix4; +typedef glm::mat4 Matrix4; } #endif diff --git a/modules/system/include/moon/mrb/clock.hxx b/modules/system/include/moon/mrb/clock.hxx index 2486709..c197726 100644 --- a/modules/system/include/moon/mrb/clock.hxx +++ b/modules/system/include/moon/mrb/clock.hxx @@ -1,18 +1,18 @@ #ifndef MMRB_CLOCK_H #define MMRB_CLOCK_H +#include "moon/api.h" +#include "moon/fps.hxx" #include #include #include #include -#include "moon/api.h" -#include "moon/fps.hxx" MOON_C_API const struct mrb_data_type clock_data_type; -MOON_C_API void mmrb_clock_init(mrb_state *mrb); +MOON_C_API void mmrb_clock_init(mrb_state* mrb); static inline Moon::FPS* -mmrb_clock_ptr(mrb_state *mrb, mrb_value self) +mmrb_clock_ptr(mrb_state* mrb, mrb_value self) { return static_cast(mrb_data_get_ptr(mrb, self, &clock_data_type)); } diff --git a/modules/system/include/moon/mrb/context.hxx b/modules/system/include/moon/mrb/context.hxx index 00e9b48..3e40f2c 100644 --- a/modules/system/include/moon/mrb/context.hxx +++ b/modules/system/include/moon/mrb/context.hxx @@ -1,12 +1,12 @@ #ifndef MMRB_CONTEXT_H #define MMRB_CONTEXT_H +#include "moon/api.h" #include #include #include -#include "moon/api.h" MOON_C_API const struct mrb_data_type context_data_type; -MOON_C_API void mmrb_context_init(mrb_state *mrb); +MOON_C_API void mmrb_context_init(mrb_state* mrb); #endif diff --git a/modules/system/include/moon/mrb/helpers.hxx b/modules/system/include/moon/mrb/helpers.hxx index 86234d0..53a84c7 100644 --- a/modules/system/include/moon/mrb/helpers.hxx +++ b/modules/system/include/moon/mrb/helpers.hxx @@ -7,22 +7,26 @@ #include #define IVget(_name_) mrb_iv_get(mrb, self, mrb_intern_lit(mrb, _name_)) -#define IVset(_name_, _value_) mrb_iv_set(mrb, self, mrb_intern_lit(mrb, _name_), _value_) +#define IVset(_name_, _value_) \ + mrb_iv_set(mrb, self, mrb_intern_lit(mrb, _name_), _value_) #define KEY_SHADER "@shader" #define KEY_VBO "@vbo" #define KEY_ORIGIN "@origin" -#define MOON_GET_CLASS(__name__) mrb_class_get_under(mrb, mrb_module_get(mrb, "Moon"), __name__) -#define MOON_GET_MODULE(__name__) mrb_module_get_under(mrb, mrb_module_get(mrb, "Moon"), __name__) +#define MOON_GET_CLASS(__name__) \ + mrb_class_get_under(mrb, mrb_module_get(mrb, "Moon"), __name__) +#define MOON_GET_MODULE(__name__) \ + mrb_module_get_under(mrb, mrb_module_get(mrb, "Moon"), __name__) ; static inline mrb_value -moon_iv_get(mrb_state *mrb, mrb_value self, const char *name) +moon_iv_get(mrb_state* mrb, mrb_value self, const char* name) { mrb_value iv_value = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, name)); if (mrb_nil_p(iv_value)) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, "Cannot use a nil %S", mrb_str_new_cstr(mrb, name)); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "Cannot use a nil %S", + mrb_str_new_cstr(mrb, name)); } return iv_value; } diff --git a/modules/system/include/moon/mrb/matrix4.hxx b/modules/system/include/moon/mrb/matrix4.hxx index 5454fc2..0139408 100644 --- a/modules/system/include/moon/mrb/matrix4.hxx +++ b/modules/system/include/moon/mrb/matrix4.hxx @@ -1,28 +1,29 @@ #ifndef MMRB_TRANSFORM_H #define MMRB_TRANSFORM_H -#include -#include -#include #include "moon/api.h" #include "moon/matrix4.hxx" #include "moon/mrb/helpers.hxx" +#include +#include +#include MOON_C_API const struct mrb_data_type matrix4_data_type; -MOON_C_API void mmrb_matrix4_init(mrb_state *mrb); -MOON_C_API mrb_value mmrb_matrix4_value(mrb_state *mrb, Moon::Matrix4 mat); -MOON_C_API Moon::Matrix4 mmrb_to_matrix4(mrb_state *mrb, mrb_value self); +MOON_C_API void mmrb_matrix4_init(mrb_state* mrb); +MOON_C_API mrb_value mmrb_matrix4_value(mrb_state* mrb, Moon::Matrix4 mat); +MOON_C_API Moon::Matrix4 mmrb_to_matrix4(mrb_state* mrb, mrb_value self); static inline struct RClass* -mmrb_get_matrix4_class(mrb_state *mrb) +mmrb_get_matrix4_class(mrb_state* mrb) { return MOON_GET_CLASS("Matrix4"); } static inline Moon::Matrix4* -mmrb_matrix4_ptr(mrb_state *mrb, mrb_value self) +mmrb_matrix4_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &matrix4_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &matrix4_data_type)); } #endif diff --git a/modules/system/include/moon/mrb/rect.hxx b/modules/system/include/moon/mrb/rect.hxx index 231f433..0de876e 100644 --- a/modules/system/include/moon/mrb/rect.hxx +++ b/modules/system/include/moon/mrb/rect.hxx @@ -1,30 +1,31 @@ #ifndef MMRB_RECT_H #define MMRB_RECT_H +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" +#include "moon/rect.hxx" #include #include #include #include -#include "moon/api.h" -#include "moon/rect.hxx" -#include "moon/mrb/helpers.hxx" MOON_C_API const struct mrb_data_type rect_data_type; -MOON_C_API void mmrb_rect_init(mrb_state *mrb); -MOON_C_API mrb_value mmrb_rect_value(mrb_state *mrb, Moon::IntRect rect); -MOON_C_API Moon::IntRect mmrb_to_rect(mrb_state *mrb, mrb_value obj); -MOON_C_API Moon::FloatRect mmrb_to_float_rect(mrb_state *mrb, mrb_value obj); +MOON_C_API void mmrb_rect_init(mrb_state* mrb); +MOON_C_API mrb_value mmrb_rect_value(mrb_state* mrb, Moon::IntRect rect); +MOON_C_API Moon::IntRect mmrb_to_rect(mrb_state* mrb, mrb_value obj); +MOON_C_API Moon::FloatRect mmrb_to_float_rect(mrb_state* mrb, mrb_value obj); static inline struct RClass* -mmrb_get_rect_class(mrb_state *mrb) +mmrb_get_rect_class(mrb_state* mrb) { return MOON_GET_CLASS("Rect"); } static inline Moon::IntRect* -mmrb_rect_ptr(mrb_state *mrb, mrb_value self) +mmrb_rect_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &rect_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &rect_data_type)); } #endif diff --git a/modules/system/include/moon/mrb/vector1.hxx b/modules/system/include/moon/mrb/vector1.hxx index cffe443..6ee1b0d 100644 --- a/modules/system/include/moon/mrb/vector1.hxx +++ b/modules/system/include/moon/mrb/vector1.hxx @@ -1,33 +1,34 @@ #ifndef MMRB_VECTOR1_H #define MMRB_VECTOR1_H +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" +#include "moon/vector1.hxx" #include #include #include #include -#include "moon/api.h" -#include "moon/vector1.hxx" -#include "moon/mrb/helpers.hxx" MOON_C_API const struct mrb_data_type vector1_data_type; -MOON_C_API void mmrb_vector1_init(mrb_state *mrb); -MOON_C_API Moon::Vector1 mmrb_to_vector1(mrb_state *mrb, mrb_value obj); -MOON_C_API mrb_value mmrb_vector1_value(mrb_state *mrb, Moon::Vector1 v1); +MOON_C_API void mmrb_vector1_init(mrb_state* mrb); +MOON_C_API Moon::Vector1 mmrb_to_vector1(mrb_state* mrb, mrb_value obj); +MOON_C_API mrb_value mmrb_vector1_value(mrb_state* mrb, Moon::Vector1 v1); static inline struct RClass* -mmrb_get_vector1_class(mrb_state *mrb) +mmrb_get_vector1_class(mrb_state* mrb) { return MOON_GET_CLASS("Vector1"); } static inline Moon::Vector1* -mmrb_vector1_ptr(mrb_state *mrb, mrb_value self) +mmrb_vector1_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &vector1_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &vector1_data_type)); } static inline mrb_float -mmrb_to_flo(mrb_state *mrb, mrb_value obj) +mmrb_to_flo(mrb_state* mrb, mrb_value obj) { if (mrb_type(obj) == MRB_TT_DATA) { if (DATA_TYPE(obj) == &vector1_data_type) { diff --git a/modules/system/include/moon/mrb/vector2.hxx b/modules/system/include/moon/mrb/vector2.hxx index c63b38b..dead151 100644 --- a/modules/system/include/moon/mrb/vector2.hxx +++ b/modules/system/include/moon/mrb/vector2.hxx @@ -1,28 +1,29 @@ #ifndef MMRB_VECTOR2_H #define MMRB_VECTOR2_H +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" +#include "moon/vector2.hxx" #include #include #include -#include "moon/api.h" -#include "moon/vector2.hxx" -#include "moon/mrb/helpers.hxx" MOON_C_API const struct mrb_data_type vector2_data_type; -MOON_C_API void mmrb_vector2_init(mrb_state *mrb); -MOON_C_API Moon::Vector2 mmrb_to_vector2(mrb_state *mrb, mrb_value obj); -MOON_C_API mrb_value mmrb_vector2_value(mrb_state *mrb, Moon::Vector2 v2); +MOON_C_API void mmrb_vector2_init(mrb_state* mrb); +MOON_C_API Moon::Vector2 mmrb_to_vector2(mrb_state* mrb, mrb_value obj); +MOON_C_API mrb_value mmrb_vector2_value(mrb_state* mrb, Moon::Vector2 v2); static inline struct RClass* -mmrb_get_vector2_class(mrb_state *mrb) +mmrb_get_vector2_class(mrb_state* mrb) { return MOON_GET_CLASS("Vector2"); } static inline Moon::Vector2* -mmrb_vector2_ptr(mrb_state *mrb, mrb_value self) +mmrb_vector2_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &vector2_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &vector2_data_type)); } #endif diff --git a/modules/system/include/moon/mrb/vector3.hxx b/modules/system/include/moon/mrb/vector3.hxx index 7983f13..d8d528d 100644 --- a/modules/system/include/moon/mrb/vector3.hxx +++ b/modules/system/include/moon/mrb/vector3.hxx @@ -1,28 +1,29 @@ #ifndef MMRB_VECTOR3_H #define MMRB_VECTOR3_H +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" +#include "moon/vector3.hxx" #include #include #include -#include "moon/api.h" -#include "moon/vector3.hxx" -#include "moon/mrb/helpers.hxx" MOON_C_API const struct mrb_data_type vector3_data_type; -MOON_C_API void mmrb_vector3_init(mrb_state *mrb); -MOON_C_API Moon::Vector3 mmrb_to_vector3(mrb_state *mrb, mrb_value obj); -MOON_C_API mrb_value mmrb_vector3_value(mrb_state *mrb, Moon::Vector3 v3); +MOON_C_API void mmrb_vector3_init(mrb_state* mrb); +MOON_C_API Moon::Vector3 mmrb_to_vector3(mrb_state* mrb, mrb_value obj); +MOON_C_API mrb_value mmrb_vector3_value(mrb_state* mrb, Moon::Vector3 v3); static inline struct RClass* -mmrb_get_vector3_class(mrb_state *mrb) +mmrb_get_vector3_class(mrb_state* mrb) { return MOON_GET_CLASS("Vector3"); } static inline Moon::Vector3* -mmrb_vector3_ptr(mrb_state *mrb, mrb_value self) +mmrb_vector3_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &vector3_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &vector3_data_type)); } #endif diff --git a/modules/system/include/moon/mrb/vector4.hxx b/modules/system/include/moon/mrb/vector4.hxx index 13a34cf..20337fc 100644 --- a/modules/system/include/moon/mrb/vector4.hxx +++ b/modules/system/include/moon/mrb/vector4.hxx @@ -1,28 +1,29 @@ #ifndef MMRB_VECTOR4_H #define MMRB_VECTOR4_H +#include "moon/api.h" +#include "moon/mrb/helpers.hxx" +#include "moon/vector4.hxx" #include #include #include -#include "moon/api.h" -#include "moon/vector4.hxx" -#include "moon/mrb/helpers.hxx" MOON_C_API const struct mrb_data_type vector4_data_type; -MOON_C_API void mmrb_vector4_init(mrb_state *mrb); -MOON_C_API Moon::Vector4 mmrb_to_vector4(mrb_state *mrb, mrb_value obj); -MOON_C_API mrb_value mmrb_vector4_value(mrb_state *mrb, Moon::Vector4 v4); +MOON_C_API void mmrb_vector4_init(mrb_state* mrb); +MOON_C_API Moon::Vector4 mmrb_to_vector4(mrb_state* mrb, mrb_value obj); +MOON_C_API mrb_value mmrb_vector4_value(mrb_state* mrb, Moon::Vector4 v4); static inline struct RClass* -mmrb_get_vector4_class(mrb_state *mrb) +mmrb_get_vector4_class(mrb_state* mrb) { return MOON_GET_CLASS("Vector4"); } static inline Moon::Vector4* -mmrb_vector4_ptr(mrb_state *mrb, mrb_value self) +mmrb_vector4_ptr(mrb_state* mrb, mrb_value self) { - return static_cast(mrb_data_get_ptr(mrb, self, &vector4_data_type)); + return static_cast( + mrb_data_get_ptr(mrb, self, &vector4_data_type)); } #endif diff --git a/modules/system/include/moon/mrb/vector_unroll.hxx b/modules/system/include/moon/mrb/vector_unroll.hxx index f135a86..2840394 100644 --- a/modules/system/include/moon/mrb/vector_unroll.hxx +++ b/modules/system/include/moon/mrb/vector_unroll.hxx @@ -1,14 +1,14 @@ #ifndef MRB_MOON_VECTOR_UNROLL #define MRB_MOON_VECTOR_UNROLL -#include -#include -#include -#include #include "moon/mrb/vector1.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" +#include +#include +#include +#include /* Vector unrolling * @param [mrb_state*] mrb @@ -18,13 +18,13 @@ * @param [mrb_float] result target buffer */ static inline int -mmrb_vector_unroll(mrb_state *mrb, size_t argc, mrb_value *vals, size_t result_size, mrb_float *result) +mmrb_vector_unroll(mrb_state* mrb, size_t argc, mrb_value* vals, + size_t result_size, mrb_float* result) { if (argc < 1 || argc > result_size) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1..%S)", - mrb_fixnum_value(argc), - mrb_fixnum_value(result_size)); + mrb_fixnum_value(argc), mrb_fixnum_value(result_size)); } size_t index = 0; @@ -32,67 +32,75 @@ mmrb_vector_unroll(mrb_state *mrb, size_t argc, mrb_value *vals, size_t result_s mrb_value val = vals[i]; switch (mrb_type(val)) { case MRB_TT_FIXNUM: - case MRB_TT_FLOAT: - { + case MRB_TT_FLOAT: { result[index++] = mrb_to_flo(mrb, val); break; } - case MRB_TT_ARRAY: - { + case MRB_TT_ARRAY: { size_t len = mrb_ary_len(mrb, val); for (size_t j = 0; j < len; ++j) { result[index++] = mmrb_to_flo(mrb, mrb_ary_entry(val, j)); - if (index >= 4) break; + if (index >= 4) + break; } break; } - case MRB_TT_DATA: - { - const mrb_data_type *t = (mrb_data_type*)DATA_TYPE(val); + case MRB_TT_DATA: { + const mrb_data_type* t = (mrb_data_type*)DATA_TYPE(val); if (t == &vector1_data_type) { result[index++] = mmrb_to_flo(mrb, val); break; } else if (t == &vector2_data_type) { Moon::Vector2 v2 = *mmrb_vector2_ptr(mrb, val); - result[index++] = v2[0]; if (index >= result_size) break; + result[index++] = v2[0]; + if (index >= result_size) + break; result[index++] = v2[1]; break; } else if (t == &vector3_data_type) { Moon::Vector3 v3 = *mmrb_vector3_ptr(mrb, val); - result[index++] = v3[0]; if (index >= result_size) break; - result[index++] = v3[1]; if (index >= result_size) break; + result[index++] = v3[0]; + if (index >= result_size) + break; + result[index++] = v3[1]; + if (index >= result_size) + break; result[index++] = v3[2]; break; } else if (t == &vector4_data_type) { Moon::Vector4 v4 = *mmrb_vector4_ptr(mrb, val); - result[index++] = v4[0]; if (index >= result_size) break; - result[index++] = v4[1]; if (index >= result_size) break; - result[index++] = v4[2]; if (index >= result_size) break; + result[index++] = v4[0]; + if (index >= result_size) + break; + result[index++] = v4[1]; + if (index >= result_size) + break; + result[index++] = v4[2]; + if (index >= result_size) + break; result[index++] = v4[3]; break; } else { - mrb_raisef(mrb, E_TYPE_ERROR, - "wrong type %S (expected a Vector*)", + mrb_raisef(mrb, E_TYPE_ERROR, "wrong type %S (expected a Vector*)", mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, val))); } } default: { - mrb_raisef(mrb, E_TYPE_ERROR, - "wrong type %S (expected Array, Numeric, Vector1, Vector2, Vector3, or Vector4)", + mrb_raisef(mrb, E_TYPE_ERROR, "wrong type %S (expected Array, Numeric, " + "Vector1, Vector2, Vector3, or Vector4)", mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, val))); } } - if (index >= result_size) break; + if (index >= result_size) + break; }; if (index == 1) { for (size_t i = 1; i < result_size; ++i) { result[i] = result[0]; } } else if (index < result_size) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, - "unrolled %S parameter(s) (required %S)", - mrb_fixnum_value(index), - mrb_fixnum_value(result_size)); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "unrolled %S parameter(s) (required %S)", + mrb_fixnum_value(index), mrb_fixnum_value(result_size)); } return index; } diff --git a/modules/system/include/moon/mrb_err.hxx b/modules/system/include/moon/mrb_err.hxx index 6f4ab47..0799ec8 100644 --- a/modules/system/include/moon/mrb_err.hxx +++ b/modules/system/include/moon/mrb_err.hxx @@ -1,11 +1,12 @@ #ifndef MOON_MRB_ERR_H #define MOON_MRB_ERR_H -#include #include #include #include +#include -extern bool mmrb_check_class(mrb_state *mrb, mrb_value obj, struct RClass *klass, bool quiet); +extern bool mmrb_check_class(mrb_state* mrb, mrb_value obj, + struct RClass* klass, bool quiet); #endif diff --git a/modules/system/include/moon/rect.hxx b/modules/system/include/moon/rect.hxx index 3c79c27..085270f 100644 --- a/modules/system/include/moon/rect.hxx +++ b/modules/system/include/moon/rect.hxx @@ -2,24 +2,28 @@ #define MOON_RECT_H namespace Moon { - template struct Rect { - T x, y, w, h; - Rect() = default; - Rect(T _x, T _y, T _w, T _h) { - x = _x; - y = _y; - w = _w; - h = _h; - }; - Rect(const Moon::Rect &r) { - x = r.x; - y = r.y; - w = r.w; - h = r.h; - }; +template +struct Rect +{ + T x, y, w, h; + Rect() = default; + Rect(T _x, T _y, T _w, T _h) + { + x = _x; + y = _y; + w = _w; + h = _h; }; - typedef Rect IntRect; - typedef Rect FloatRect; + Rect(const Moon::Rect& r) + { + x = r.x; + y = r.y; + w = r.w; + h = r.h; + }; +}; +typedef Rect IntRect; +typedef Rect FloatRect; }; #endif diff --git a/modules/system/include/moon/string.hxx b/modules/system/include/moon/string.hxx index ce54a21..ed2f18e 100644 --- a/modules/system/include/moon/string.hxx +++ b/modules/system/include/moon/string.hxx @@ -1,9 +1,9 @@ #ifndef MOON_STRING_H_ #define MOON_STRING_H_ +#include #include #include -#include #include static inline wchar_t* @@ -11,19 +11,22 @@ chars_to_utf8(const char* str) { #ifdef _WIN32 // get length of converted string in characters - const size_t length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str, sizeof(str), NULL, 0); - wchar_t *name = new wchar_t[length]; - MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str, sizeof(str), name, length); + const size_t length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str, + sizeof(str), NULL, 0); + wchar_t* name = new wchar_t[length]; + MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str, sizeof(str), name, + length); return name; #else const size_t length = mbstowcs(0, str, 0); - wchar_t *text = new wchar_t[length+1]; - mbstowcs(text, str, length+1); + wchar_t* text = new wchar_t[length + 1]; + mbstowcs(text, str, length + 1); return text; #endif }; -struct Utf8ToChars { +struct Utf8ToChars +{ size_t length; char* str; }; @@ -43,80 +46,68 @@ utf8_to_chars(const wchar_t* str) } namespace Moon { - /* String - * Glorified wchar_t wrapper. - */ - class WString { - public: - WString(wchar_t *str) { - m_length = wcslen(str); - m_str = new wchar_t[m_length]; - memcpy(m_str, str, m_length * sizeof(wchar_t)); - } - - WString(char *str) { - m_str = chars_to_utf8(str); - m_length = wcslen(m_str); - } - - ~WString() { - delete[] m_str; - } - - wchar_t operator[](size_t index) const { - return m_str[index]; - } - - size_t length() const { - return m_length; - } - - const wchar_t* c_str() const { - return m_str; - } - private: - wchar_t *m_str; - size_t m_length; - }; - - class String { - public: - String(wchar_t *str) { - const Utf8ToChars data = utf8_to_chars(str); - m_str = data.str; - m_length = data.length; - } - - String(char *str) { - /* Definetly not sure about this, so best if we don't use it */ - m_length = strlen(str); - m_str = new char[m_length]; - memcpy(m_str, str, m_length * sizeof(char)); - } - - ~String() { - delete[] m_str; - } - - char* get_cptr(size_t index) const { - return &(m_str[index]); - } - - char operator[](size_t index) const { - return m_str[index]; - } - - size_t length() const { - return m_length; - } - - const char* c_str() const { - return m_str; - } - private: - char *m_str; - size_t m_length; - }; +/* String + * Glorified wchar_t wrapper. + */ +class WString +{ +public: + WString(wchar_t* str) + { + m_length = wcslen(str); + m_str = new wchar_t[m_length]; + memcpy(m_str, str, m_length * sizeof(wchar_t)); + } + + WString(char* str) + { + m_str = chars_to_utf8(str); + m_length = wcslen(m_str); + } + + ~WString() { delete[] m_str; } + + wchar_t operator[](size_t index) const { return m_str[index]; } + + size_t length() const { return m_length; } + + const wchar_t* c_str() const { return m_str; } +private: + wchar_t* m_str; + size_t m_length; +}; + +class String +{ +public: + String(wchar_t* str) + { + const Utf8ToChars data = utf8_to_chars(str); + m_str = data.str; + m_length = data.length; + } + + String(char* str) + { + /* Definetly not sure about this, so best if we don't use it */ + m_length = strlen(str); + m_str = new char[m_length]; + memcpy(m_str, str, m_length * sizeof(char)); + } + + ~String() { delete[] m_str; } + + char* get_cptr(size_t index) const { return &(m_str[index]); } + + char operator[](size_t index) const { return m_str[index]; } + + size_t length() const { return m_length; } + + const char* c_str() const { return m_str; } +private: + char* m_str; + size_t m_length; +}; } #endif diff --git a/modules/system/include/moon/vector1.hxx b/modules/system/include/moon/vector1.hxx index 9d96bf4..7ab795a 100644 --- a/modules/system/include/moon/vector1.hxx +++ b/modules/system/include/moon/vector1.hxx @@ -4,8 +4,8 @@ #include "moon/glm.h" namespace Moon { - typedef glm::highp_vec1_t Vector1; - typedef glm::highp_ivec1_t Vector1i; +typedef glm::highp_vec1_t Vector1; +typedef glm::highp_ivec1_t Vector1i; } #endif diff --git a/modules/system/include/moon/vector2.hxx b/modules/system/include/moon/vector2.hxx index 7aa842c..c45a9b5 100644 --- a/modules/system/include/moon/vector2.hxx +++ b/modules/system/include/moon/vector2.hxx @@ -4,7 +4,7 @@ #include "moon/glm.h" namespace Moon { - typedef glm::vec2 Vector2; +typedef glm::vec2 Vector2; } #endif diff --git a/modules/system/include/moon/vector3.hxx b/modules/system/include/moon/vector3.hxx index ffe1016..1dd78de 100644 --- a/modules/system/include/moon/vector3.hxx +++ b/modules/system/include/moon/vector3.hxx @@ -4,7 +4,7 @@ #include "moon/glm.h" namespace Moon { - typedef glm::vec3 Vector3; +typedef glm::vec3 Vector3; } #endif diff --git a/modules/system/include/moon/vector4.hxx b/modules/system/include/moon/vector4.hxx index c5e6432..6ddd140 100644 --- a/modules/system/include/moon/vector4.hxx +++ b/modules/system/include/moon/vector4.hxx @@ -4,7 +4,7 @@ #include "moon/glm.h" namespace Moon { - typedef glm::vec4 Vector4; +typedef glm::vec4 Vector4; } #endif diff --git a/modules/system/src/fps.cxx b/modules/system/src/fps.cxx index 33822ef..da95b65 100644 --- a/modules/system/src/fps.cxx +++ b/modules/system/src/fps.cxx @@ -1,38 +1,47 @@ -#include #include "moon/fps.hxx" +#include namespace Moon { - FPS::FPS() { - m_old_time = 0.0; - m_last_time = 0.0; - m_delta = 0.0; - m_frames = 0; - m_fps = 0; - } +FPS::FPS() +{ + m_old_time = 0.0; + m_last_time = 0.0; + m_delta = 0.0; + m_frames = 0; + m_fps = 0; +} - float FPS::GetDelta() { - return m_delta; - }; +float +FPS::GetDelta() +{ + return m_delta; +}; - int FPS::GetFPS() { - return m_fps; - } +int +FPS::GetFPS() +{ + return m_fps; +} - void FPS::Update() { - float now = glfwGetTime(); - if ((m_old_time + 1.0f) < now) { - m_old_time = now; - m_fps = m_frames; - m_frames = 0; - } - m_delta = now - m_last_time; - m_last_time = now; - m_frames++; +void +FPS::Update() +{ + float now = glfwGetTime(); + if ((m_old_time + 1.0f) < now) { + m_old_time = now; + m_fps = m_frames; + m_frames = 0; } + m_delta = now - m_last_time; + m_last_time = now; + m_frames++; +} - float FPS::Restart() { - float d = GetDelta(); - Update(); - return d; - }; +float +FPS::Restart() +{ + float d = GetDelta(); + Update(); + return d; +}; } diff --git a/modules/system/src/mrb_clock.cxx b/modules/system/src/mrb_clock.cxx index 65ff060..740e3c4 100644 --- a/modules/system/src/mrb_clock.cxx +++ b/modules/system/src/mrb_clock.cxx @@ -1,26 +1,26 @@ +#include "moon/api.h" +#include "moon/fps.hxx" +#include "moon/mrb/clock.hxx" #include #include #include #include -#include "moon/api.h" -#include "moon/mrb/clock.hxx" -#include "moon/fps.hxx" static void -clock_free(mrb_state *mrb, void *ptr) +clock_free(mrb_state* mrb, void* ptr) { - Moon::FPS *clk = (Moon::FPS*)ptr; + Moon::FPS* clk = (Moon::FPS*)ptr; if (clk) { - delete(clk); + delete (clk); } } MOON_C_API const mrb_data_type clock_data_type = { "Moon::FPS", clock_free }; static inline void -clock_cleanup(mrb_state *mrb, mrb_value self) +clock_cleanup(mrb_state* mrb, mrb_value self) { - void *ptr = DATA_PTR(self); + void* ptr = DATA_PTR(self); if (ptr) { clock_free(mrb, ptr); } @@ -28,7 +28,7 @@ clock_cleanup(mrb_state *mrb, mrb_value self) } static mrb_value -clock_initialize(mrb_state *mrb, mrb_value self) +clock_initialize(mrb_state* mrb, mrb_value self) { clock_cleanup(mrb, self); mrb_data_init(self, new Moon::FPS(), &clock_data_type); @@ -36,7 +36,7 @@ clock_initialize(mrb_state *mrb, mrb_value self) } static mrb_value -clock_initialize_copy(mrb_state *mrb, mrb_value self) +clock_initialize_copy(mrb_state* mrb, mrb_value self) { clock_cleanup(mrb, self); mrb_data_init(self, new Moon::FPS(), &clock_data_type); @@ -48,7 +48,7 @@ clock_initialize_copy(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -clock_restart(mrb_state *mrb, mrb_value self) +clock_restart(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_clock_ptr(mrb, self)->Restart()); } @@ -58,7 +58,7 @@ clock_restart(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -clock_update(mrb_state *mrb, mrb_value self) +clock_update(mrb_state* mrb, mrb_value self) { mmrb_clock_ptr(mrb, self)->Update(); return self; @@ -68,7 +68,7 @@ clock_update(mrb_state *mrb, mrb_value self) * @return [Float] Returns the time since last frame (in ms) */ static mrb_value -clock_delta(mrb_state *mrb, mrb_value self) +clock_delta(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_clock_ptr(mrb, self)->GetDelta()); } @@ -78,25 +78,29 @@ clock_delta(mrb_state *mrb, mrb_value self) * @return [Integer] */ static mrb_value -clock_fps(mrb_state *mrb, mrb_value self) +clock_fps(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_clock_ptr(mrb, self)->GetFPS()); } MOON_C_API void -mmrb_clock_init(mrb_state *mrb) +mmrb_clock_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); + struct RClass* mod = mrb_define_module(mrb, "Moon"); /* Utility class for tracking time. Internally uses glfw to get high precision * time. */ - struct RClass *clock_class = mrb_define_class_under(mrb, mod, "Clock", mrb->object_class); + struct RClass* clock_class = + mrb_define_class_under(mrb, mod, "Clock", mrb->object_class); MRB_SET_INSTANCE_TT(clock_class, MRB_TT_DATA); - mrb_define_method(mrb, clock_class, "initialize", clock_initialize, MRB_ARGS_NONE()); - mrb_define_method(mrb, clock_class, "initialize_copy", clock_initialize_copy, MRB_ARGS_NONE()); - mrb_define_method(mrb, clock_class, "restart", clock_restart, MRB_ARGS_NONE()); - mrb_define_method(mrb, clock_class, "update", clock_update, MRB_ARGS_NONE()); - mrb_define_method(mrb, clock_class, "delta", clock_delta, MRB_ARGS_NONE()); - mrb_define_method(mrb, clock_class, "fps", clock_fps, MRB_ARGS_NONE()); + mrb_define_method(mrb, clock_class, "initialize", clock_initialize, + MRB_ARGS_NONE()); + mrb_define_method(mrb, clock_class, "initialize_copy", clock_initialize_copy, + MRB_ARGS_NONE()); + mrb_define_method(mrb, clock_class, "restart", clock_restart, + MRB_ARGS_NONE()); + mrb_define_method(mrb, clock_class, "update", clock_update, MRB_ARGS_NONE()); + mrb_define_method(mrb, clock_class, "delta", clock_delta, MRB_ARGS_NONE()); + mrb_define_method(mrb, clock_class, "fps", clock_fps, MRB_ARGS_NONE()); } diff --git a/modules/system/src/mrb_context.cxx b/modules/system/src/mrb_context.cxx index 1e849ca..73bcecb 100644 --- a/modules/system/src/mrb_context.cxx +++ b/modules/system/src/mrb_context.cxx @@ -1,21 +1,21 @@ +#include "moon/api.h" +#include "moon/mrb/context.hxx" #include #include #include #include -#include "moon/api.h" -#include "moon/mrb/context.hxx" static void -context_free(mrb_state *mrb, void *p) +context_free(mrb_state* mrb, void* p) { - mrbc_context *context = (mrbc_context*)p; + mrbc_context* context = (mrbc_context*)p; if (context) { mrbc_context_free(mrb, context); } } static inline mrbc_context* -get_context(mrb_state *mrb, mrb_value self) +get_context(mrb_state* mrb, mrb_value self) { return (mrbc_context*)mrb_data_get_ptr(mrb, self, &context_data_type); } @@ -23,9 +23,9 @@ get_context(mrb_state *mrb, mrb_value self) const struct mrb_data_type context_data_type = { "Context", context_free }; static mrb_value -context_initialize(mrb_state *mrb, mrb_value self) +context_initialize(mrb_state* mrb, mrb_value self) { - mrbc_context *cxt; + mrbc_context* cxt; cxt = (mrbc_context*)DATA_PTR(self); if (cxt) { context_free(mrb, (void*)cxt); @@ -40,11 +40,11 @@ context_initialize(mrb_state *mrb, mrb_value self) * @return [Object] v value returned from executing the string */ static mrb_value -context_eval(mrb_state *mrb, mrb_value self) +context_eval(mrb_state* mrb, mrb_value self) { char* str; mrb_get_args(mrb, "z", &str); - mrbc_context *cxt = get_context(mrb, self); + mrbc_context* cxt = get_context(mrb, self); auto v = mrb_load_string_cxt(mrb, str, cxt); if (mrb->exc) { mrb_print_error(mrb); @@ -59,10 +59,10 @@ context_eval(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -context_each_symbol(mrb_state *mrb, mrb_value self) +context_each_symbol(mrb_state* mrb, mrb_value self) { mrb_value blk; - mrbc_context *cxt = get_context(mrb, self); + mrbc_context* cxt = get_context(mrb, self); mrb_get_args(mrb, "&", &blk); for (int i = 0; i < cxt->slen; ++i) { mrb_yield(mrb, blk, mrb_symbol_value(cxt->syms[i])); @@ -71,13 +71,16 @@ context_each_symbol(mrb_state *mrb, mrb_value self) } MOON_C_API void -mmrb_context_init(mrb_state *mrb) +mmrb_context_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *context_class = mrb_define_class_under(mrb, mod, "Context", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* context_class = + mrb_define_class_under(mrb, mod, "Context", mrb->object_class); MRB_SET_INSTANCE_TT(context_class, MRB_TT_DATA); - mrb_define_method(mrb, context_class, "initialize", context_initialize, MRB_ARGS_NONE()); - mrb_define_method(mrb, context_class, "eval", context_eval, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, context_class, "each_symbol", context_each_symbol, MRB_ARGS_NONE() | MRB_ARGS_BLOCK()); + mrb_define_method(mrb, context_class, "initialize", context_initialize, + MRB_ARGS_NONE()); + mrb_define_method(mrb, context_class, "eval", context_eval, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, context_class, "each_symbol", context_each_symbol, + MRB_ARGS_NONE() | MRB_ARGS_BLOCK()); } diff --git a/modules/system/src/mrb_err.cxx b/modules/system/src/mrb_err.cxx index e6f265e..c2d5363 100644 --- a/modules/system/src/mrb_err.cxx +++ b/modules/system/src/mrb_err.cxx @@ -1,19 +1,18 @@ -#include +#include "moon/mrb_err.hxx" #include #include -#include "moon/mrb_err.hxx" +#include bool -mmrb_check_class(mrb_state *mrb, mrb_value obj, struct RClass *klass, bool quiet) +mmrb_check_class(mrb_state* mrb, mrb_value obj, struct RClass* klass, + bool quiet) { if (mrb_obj_class(mrb, obj) != klass) { if (quiet) return false; else { - mrb_raisef(mrb, E_TYPE_ERROR, - "recieved %s (expected %s)", - mrb_obj_classname(mrb, obj), - mrb_class_name(mrb, klass)); + mrb_raisef(mrb, E_TYPE_ERROR, "recieved %s (expected %s)", + mrb_obj_classname(mrb, obj), mrb_class_name(mrb, klass)); } } return true; diff --git a/modules/system/src/mrb_matrix4.cxx b/modules/system/src/mrb_matrix4.cxx index 430a294..97cdfe6 100644 --- a/modules/system/src/mrb_matrix4.cxx +++ b/modules/system/src/mrb_matrix4.cxx @@ -3,88 +3,89 @@ */ #define GLM_FORCE_RADIANS -#include -#include -#include -#include #include "moon/matrix4.hxx" #include "moon/mrb/matrix4.hxx" #include "moon/mrb/vector1.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" +#include +#include +#include +#include #define math_op_base(__op__, __target_mat4__) \ const mrb_vtype t = mrb_type(rother); \ if (t == MRB_TT_DATA) { \ - const mrb_data_type *dt = DATA_TYPE(rother); \ + const mrb_data_type* dt = DATA_TYPE(rother); \ if (dt == &matrix4_data_type) { /* Matrix4 */ \ - Moon::Matrix4 *source_mat4 = mmrb_matrix4_ptr(mrb, rother); \ - *__target_mat4__ __op__ ## = *source_mat4; \ + Moon::Matrix4* source_mat4 = mmrb_matrix4_ptr(mrb, rother); \ + *__target_mat4__ __op__## = *source_mat4; \ } else if (dt == &vector4_data_type) { /* Vector4 */ \ - *__target_mat4__ __op__ ## = mmrb_to_vector4(mrb, rother); \ + *__target_mat4__ __op__## = mmrb_to_vector4(mrb, rother); \ } \ \ } else if (t == MRB_TT_FIXNUM || t == MRB_TT_FLOAT) { /* Scalar */ \ \ - *__target_mat4__ __op__ ## = mrb_to_flo(mrb, rother); \ + *__target_mat4__ __op__## = mrb_to_flo(mrb, rother); \ } else { \ - mrb_raisef(mrb, E_TYPE_ERROR, \ - "wrong argument type %s (expected Matrix4, Vector4 or Numeric)",\ - mrb_obj_classname(mrb, rother)); \ + mrb_raisef( \ + mrb, E_TYPE_ERROR, \ + "wrong argument type %s (expected Matrix4, Vector4 or Numeric)", \ + mrb_obj_classname(mrb, rother)); \ } -#define math_op_inline(__op__) \ - Moon::Matrix4 *target_mat4; \ - mrb_value rother; \ - mrb_get_args(mrb, "o", &rother); \ - target_mat4 = mmrb_matrix4_ptr(mrb, self); \ - math_op_base(__op__, target_mat4) \ - return self; +#define math_op_inline(__op__) \ + Moon::Matrix4* target_mat4; \ + mrb_value rother; \ + mrb_get_args(mrb, "o", &rother); \ + target_mat4 = mmrb_matrix4_ptr(mrb, self); \ + math_op_base(__op__, target_mat4) return self; -#define math_op(__op__) \ - mrb_value rother; \ - mrb_get_args(mrb, "o", &rother); \ - mrb_value rtarget = mrb_obj_dup(mrb, self); \ - Moon::Matrix4 *target_mat4 = mmrb_matrix4_ptr(mrb, rtarget); \ - math_op_base(__op__, target_mat4) \ - return rtarget; /* */ +#define math_op(__op__) \ + mrb_value rother; \ + mrb_get_args(mrb, "o", &rother); \ + mrb_value rtarget = mrb_obj_dup(mrb, self); \ + Moon::Matrix4* target_mat4 = mmrb_matrix4_ptr(mrb, rtarget); \ + math_op_base(__op__, target_mat4) return rtarget; /* */ static void -matrix4_free(mrb_state *mrb, void *p) +matrix4_free(mrb_state* mrb, void* p) { - Moon::Matrix4 *matrix4 = (Moon::Matrix4*)p; + Moon::Matrix4* matrix4 = (Moon::Matrix4*)p; if (matrix4) { - delete(matrix4); + delete (matrix4); } } -MOON_C_API const struct mrb_data_type matrix4_data_type = { "Moon::Matrix4", matrix4_free }; +MOON_C_API const struct mrb_data_type matrix4_data_type = { "Moon::Matrix4", + matrix4_free }; MOON_C_API Moon::Matrix4 -mmrb_to_matrix4(mrb_state *mrb, mrb_value self) +mmrb_to_matrix4(mrb_state* mrb, mrb_value self) { return *mmrb_matrix4_ptr(mrb, self); } MOON_C_API mrb_value -mmrb_matrix4_value(mrb_state *mrb, Moon::Matrix4 mat) +mmrb_matrix4_value(mrb_state* mrb, Moon::Matrix4 mat) { mrb_value rsult = mrb_obj_new(mrb, mmrb_get_matrix4_class(mrb), 0, NULL); - Moon::Matrix4 *trns = mmrb_matrix4_ptr(mrb, rsult); + Moon::Matrix4* trns = mmrb_matrix4_ptr(mrb, rsult); *trns = mat; return rsult; } static void -matrix4_set_m(mrb_state *mrb, Moon::Matrix4 *mat, mrb_int argc, mrb_value *args) +matrix4_set_m(mrb_state* mrb, Moon::Matrix4* mat, mrb_int argc, mrb_value* args) { if (argc == 1) { mrb_value val = args[0]; if (mrb_type(val) == MRB_TT_DATA) { if (DATA_TYPE(val) == &matrix4_data_type) { /* Matrix4 */ - Moon::Matrix4 *source_mat4; - source_mat4 = (Moon::Matrix4*)mrb_data_get_ptr(mrb, val, &matrix4_data_type); + Moon::Matrix4* source_mat4; + source_mat4 = + (Moon::Matrix4*)mrb_data_get_ptr(mrb, val, &matrix4_data_type); *mat = *source_mat4; } else { mrb_raisef(mrb, E_TYPE_ERROR, @@ -103,38 +104,27 @@ matrix4_set_m(mrb_state *mrb, Moon::Matrix4 *mat, mrb_int argc, mrb_value *args) *mat = Moon::Matrix4(row1, row2, row3, row4); } else if (argc == 16) { - *mat = Moon::Matrix4( - mrb_to_flo(mrb, args[0]), - mrb_to_flo(mrb, args[1]), - mrb_to_flo(mrb, args[2]), - mrb_to_flo(mrb, args[3]), - - mrb_to_flo(mrb, args[4]), - mrb_to_flo(mrb, args[5]), - mrb_to_flo(mrb, args[6]), - mrb_to_flo(mrb, args[7]), - - mrb_to_flo(mrb, args[8]), - mrb_to_flo(mrb, args[9]), - mrb_to_flo(mrb, args[10]), - mrb_to_flo(mrb, args[11]), - - mrb_to_flo(mrb, args[12]), - mrb_to_flo(mrb, args[13]), - mrb_to_flo(mrb, args[14]), - mrb_to_flo(mrb, args[15]) - ); + *mat = Moon::Matrix4(mrb_to_flo(mrb, args[0]), mrb_to_flo(mrb, args[1]), + mrb_to_flo(mrb, args[2]), mrb_to_flo(mrb, args[3]), + + mrb_to_flo(mrb, args[4]), mrb_to_flo(mrb, args[5]), + mrb_to_flo(mrb, args[6]), mrb_to_flo(mrb, args[7]), + + mrb_to_flo(mrb, args[8]), mrb_to_flo(mrb, args[9]), + mrb_to_flo(mrb, args[10]), mrb_to_flo(mrb, args[11]), + + mrb_to_flo(mrb, args[12]), mrb_to_flo(mrb, args[13]), + mrb_to_flo(mrb, args[14]), mrb_to_flo(mrb, args[15])); } else { mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong argument count %d (expected 0, 1, 4, or 16)", - argc); + "wrong argument count %d (expected 0, 1, 4, or 16)", argc); } } static mrb_value -matrix4_set(mrb_state *mrb, mrb_value self) +matrix4_set(mrb_state* mrb, mrb_value self) { - mrb_value *args; + mrb_value* args; mrb_int argc; mrb_get_args(mrb, "*", &args, &argc); matrix4_set_m(mrb, mmrb_matrix4_ptr(mrb, self), argc, args); @@ -142,13 +132,13 @@ matrix4_set(mrb_state *mrb, mrb_value self) } static mrb_value -matrix4_initialize(mrb_state *mrb, mrb_value self) +matrix4_initialize(mrb_state* mrb, mrb_value self) { - mrb_value *args; + mrb_value* args; mrb_int argc; mrb_get_args(mrb, "*", &args, &argc); - Moon::Matrix4 *mat; + Moon::Matrix4* mat; mat = (Moon::Matrix4*)DATA_PTR(self); if (mat) { @@ -170,9 +160,9 @@ matrix4_initialize(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -matrix4_initialize_copy(mrb_state *mrb, mrb_value self) +matrix4_initialize_copy(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *source_mat; + Moon::Matrix4* source_mat; mrb_get_args(mrb, "d", &source_mat, &matrix4_data_type); matrix4_free(mrb, DATA_PTR(self)); mrb_data_init(self, new Moon::Matrix4(*source_mat), &matrix4_data_type); @@ -184,7 +174,7 @@ matrix4_initialize_copy(mrb_state *mrb, mrb_value self) * @api private */ static mrb_value -matrix4_coerce(mrb_state *mrb, mrb_value self) +matrix4_coerce(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); @@ -196,12 +186,13 @@ matrix4_coerce(mrb_state *mrb, mrb_value self) * @return [Boolean] */ static mrb_value -matrix4_eq(mrb_state *mrb, mrb_value self) +matrix4_eq(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); if (mrb_obj_is_kind_of(mrb, other, mmrb_get_matrix4_class(mrb))) { - return mrb_bool_value((*mmrb_matrix4_ptr(mrb, self)) == (*mmrb_matrix4_ptr(mrb, other))); + return mrb_bool_value((*mmrb_matrix4_ptr(mrb, self)) == + (*mmrb_matrix4_ptr(mrb, other))); } return mrb_bool_value(false); } @@ -213,13 +204,13 @@ matrix4_eq(mrb_state *mrb, mrb_value self) * @return [Numeric] */ static mrb_value -matrix4_entry_get(mrb_state *mrb, mrb_value self) +matrix4_entry_get(mrb_state* mrb, mrb_value self) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); - Moon::Matrix4 *mat4; + Moon::Matrix4* mat4; mat4 = (Moon::Matrix4*)mrb_data_get_ptr(mrb, self, &matrix4_data_type); if (len == 1) { @@ -228,8 +219,8 @@ matrix4_entry_get(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "i", &x); if (x < 0 || x >= 4) { - mrb_raisef(mrb, E_INDEX_ERROR, - "x %d is out of range (expected 0...4)", x); + mrb_raisef(mrb, E_INDEX_ERROR, "x %d is out of range (expected 0...4)", + x); return mrb_nil_value(); } @@ -240,13 +231,13 @@ matrix4_entry_get(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "ii", &x, &y); if (x < 0 || x >= 4) { - mrb_raisef(mrb, E_INDEX_ERROR, - "x %d is out of range (expected 0...4)", x); + mrb_raisef(mrb, E_INDEX_ERROR, "x %d is out of range (expected 0...4)", + x); return mrb_nil_value(); } if (y < 0 || y >= 4) { - mrb_raisef(mrb, E_INDEX_ERROR, - "y %d is out of range (expected 0...4)", y); + mrb_raisef(mrb, E_INDEX_ERROR, "y %d is out of range (expected 0...4)", + y); return mrb_nil_value(); } @@ -259,13 +250,13 @@ matrix4_entry_get(mrb_state *mrb, mrb_value self) } static mrb_value -matrix4_entry_set(mrb_state *mrb, mrb_value self) +matrix4_entry_set(mrb_state* mrb, mrb_value self) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); - Moon::Matrix4 *mat4; + Moon::Matrix4* mat4; mat4 = (Moon::Matrix4*)mrb_data_get_ptr(mrb, self, &matrix4_data_type); if (len == 2) { @@ -275,8 +266,8 @@ matrix4_entry_set(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "io", &x, &rvec4); if (x < 0 || x >= 4) { - mrb_raisef(mrb, E_INDEX_ERROR, - "x %d is out of range (expected 0...4)", x); + mrb_raisef(mrb, E_INDEX_ERROR, "x %d is out of range (expected 0...4)", + x); return mrb_nil_value(); } @@ -288,13 +279,13 @@ matrix4_entry_set(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "iif", &x, &y, &v); if (x < 0 || x >= 4) { - mrb_raisef(mrb, E_INDEX_ERROR, - "x %d is out of range (expected 0...4)", x); + mrb_raisef(mrb, E_INDEX_ERROR, "x %d is out of range (expected 0...4)", + x); return mrb_nil_value(); } if (y < 0 || y >= 4) { - mrb_raisef(mrb, E_INDEX_ERROR, - "y %d is out of range (expected 0...4)", y); + mrb_raisef(mrb, E_INDEX_ERROR, "y %d is out of range (expected 0...4)", + y); return mrb_nil_value(); } @@ -311,7 +302,7 @@ matrix4_entry_set(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_op_negate(mrb_state *mrb, mrb_value self) +matrix4_op_negate(mrb_state* mrb, mrb_value self) { mrb_value dest_mat4 = mrb_obj_dup(mrb, self); @@ -331,7 +322,7 @@ matrix4_op_negate(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_op_identity(mrb_state *mrb, mrb_value self) +matrix4_op_identity(mrb_state* mrb, mrb_value self) { return self; } @@ -340,13 +331,13 @@ matrix4_op_identity(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_op_add(mrb_state *mrb, mrb_value self) +matrix4_op_add(mrb_state* mrb, mrb_value self) { math_op(+) } static mrb_value -matrix4_add(mrb_state *mrb, mrb_value self) +matrix4_add(mrb_state* mrb, mrb_value self) { math_op_inline(+) } @@ -355,13 +346,13 @@ matrix4_add(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_op_sub(mrb_state *mrb, mrb_value self) +matrix4_op_sub(mrb_state* mrb, mrb_value self) { math_op(-) } static mrb_value -matrix4_sub(mrb_state *mrb, mrb_value self) +matrix4_sub(mrb_state* mrb, mrb_value self) { math_op_inline(-) } @@ -370,13 +361,13 @@ matrix4_sub(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_op_mul(mrb_state *mrb, mrb_value self) +matrix4_op_mul(mrb_state* mrb, mrb_value self) { math_op(*) } static mrb_value -matrix4_mul(mrb_state *mrb, mrb_value self) +matrix4_mul(mrb_state* mrb, mrb_value self) { math_op_inline(*) } @@ -384,14 +375,10 @@ matrix4_mul(mrb_state *mrb, mrb_value self) /* * @return [Matrix4] */ -static mrb_value -matrix4_op_div(mrb_state *mrb, mrb_value self) -{ - math_op(/) -}; +static mrb_value matrix4_op_div(mrb_state* mrb, mrb_value self){ math_op(/) }; static mrb_value -matrix4_div(mrb_state *mrb, mrb_value self) +matrix4_div(mrb_state* mrb, mrb_value self) { math_op_inline(/) } @@ -399,8 +386,8 @@ matrix4_div(mrb_state *mrb, mrb_value self) /* * @return [Matrix4] */ -//static mrb_value -//matrix4_op_mod(mrb_state *mrb, mrb_value self) +// static mrb_value +// matrix4_op_mod(mrb_state *mrb, mrb_value self) //{ // math_op(%) //} @@ -411,9 +398,9 @@ matrix4_div(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -matrix4_clear(mrb_state *mrb, mrb_value self) +matrix4_clear(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *mat4 = mmrb_matrix4_ptr(mrb, self); + Moon::Matrix4* mat4 = mmrb_matrix4_ptr(mrb, self); *mat4 = Moon::Matrix4(1.0f); return self; } @@ -422,25 +409,23 @@ matrix4_clear(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static Moon::Matrix4 -matrix4_translate_m(mrb_state *mrb, mrb_value self) +matrix4_translate_m(mrb_state* mrb, mrb_value self) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); - Moon::Matrix4 *mat4 = mmrb_matrix4_ptr(mrb, self); + Moon::Matrix4* mat4 = mmrb_matrix4_ptr(mrb, self); Moon::Matrix4 target_mat4; if (len == 1) { glm::vec3 v3 = mmrb_to_vector3(mrb, vals[0]); target_mat4 = glm::translate(*mat4, v3); } else if (len == 3) { - target_mat4 = glm::translate(*mat4, glm::vec3( - mrb_to_flo(mrb, vals[0]), - mrb_to_flo(mrb, vals[1]), - mrb_to_flo(mrb, vals[2]))); + target_mat4 = glm::translate(*mat4, glm::vec3(mrb_to_flo(mrb, vals[0]), + mrb_to_flo(mrb, vals[1]), + mrb_to_flo(mrb, vals[2]))); } else { mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong argument count %d (expected 1 or 3)", - len); + "wrong argument count %d (expected 1 or 3)", len); } return target_mat4; }; @@ -449,9 +434,9 @@ matrix4_translate_m(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_translate(mrb_state *mrb, mrb_value self) +matrix4_translate(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *target_mat4; + Moon::Matrix4* target_mat4; Moon::Matrix4 mat4 = matrix4_translate_m(mrb, self); mrb_value rtarget = mrb_obj_dup(mrb, self); target_mat4 = mmrb_matrix4_ptr(mrb, rtarget); @@ -460,9 +445,9 @@ matrix4_translate(mrb_state *mrb, mrb_value self) }; static mrb_value -matrix4_translate_bang(mrb_state *mrb, mrb_value self) +matrix4_translate_bang(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *target_mat4; + Moon::Matrix4* target_mat4; Moon::Matrix4 mat4 = matrix4_translate_m(mrb, self); target_mat4 = mmrb_matrix4_ptr(mrb, self); *target_mat4 = mat4; @@ -473,12 +458,12 @@ matrix4_translate_bang(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static Moon::Matrix4 -matrix4_rotate_m(mrb_state *mrb, mrb_value self) +matrix4_rotate_m(mrb_state* mrb, mrb_value self) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); - Moon::Matrix4 *mat4 = mmrb_matrix4_ptr(mrb, self); + Moon::Matrix4* mat4 = mmrb_matrix4_ptr(mrb, self); Moon::Matrix4 target_mat4; if (len == 2) { @@ -487,15 +472,13 @@ matrix4_rotate_m(mrb_state *mrb, mrb_value self) target_mat4 = glm::rotate(*mat4, glm::radians((float)angle), rotate_v3); } else if (len == 4) { - target_mat4 = glm::rotate(*mat4, - glm::radians((float)mrb_to_flo(mrb, vals[0])), - glm::vec3(mrb_to_flo(mrb, vals[1]), - mrb_to_flo(mrb, vals[2]), - mrb_to_flo(mrb, vals[3]))); + target_mat4 = + glm::rotate(*mat4, glm::radians((float)mrb_to_flo(mrb, vals[0])), + glm::vec3(mrb_to_flo(mrb, vals[1]), mrb_to_flo(mrb, vals[2]), + mrb_to_flo(mrb, vals[3]))); } else { mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong argument count %d (expected 2 or 4)", - len); + "wrong argument count %d (expected 2 or 4)", len); } return target_mat4; } @@ -504,9 +487,9 @@ matrix4_rotate_m(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_rotate(mrb_state *mrb, mrb_value self) +matrix4_rotate(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *target_mat4; + Moon::Matrix4* target_mat4; Moon::Matrix4 mat4 = matrix4_rotate_m(mrb, self); mrb_value rtarget = mrb_obj_dup(mrb, self); target_mat4 = mmrb_matrix4_ptr(mrb, rtarget); @@ -515,9 +498,9 @@ matrix4_rotate(mrb_state *mrb, mrb_value self) }; static mrb_value -matrix4_rotate_bang(mrb_state *mrb, mrb_value self) +matrix4_rotate_bang(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *target_mat4; + Moon::Matrix4* target_mat4; Moon::Matrix4 mat4 = matrix4_rotate_m(mrb, self); target_mat4 = mmrb_matrix4_ptr(mrb, self); *target_mat4 = mat4; @@ -525,13 +508,13 @@ matrix4_rotate_bang(mrb_state *mrb, mrb_value self) }; static Moon::Matrix4 -matrix4_scale_m(mrb_state *mrb, mrb_value self) +matrix4_scale_m(mrb_state* mrb, mrb_value self) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); - Moon::Matrix4 *mat4 = mmrb_matrix4_ptr(mrb, self); + Moon::Matrix4* mat4 = mmrb_matrix4_ptr(mrb, self); Moon::Matrix4 target_mat4; if (len == 1) { @@ -539,22 +522,20 @@ matrix4_scale_m(mrb_state *mrb, mrb_value self) target_mat4 = glm::scale(*mat4, v3); } else if (len == 3) { - target_mat4 = glm::scale(*mat4, glm::vec3( - mrb_to_flo(mrb, vals[0]), - mrb_to_flo(mrb, vals[1]), - mrb_to_flo(mrb, vals[2]))); + target_mat4 = glm::scale(*mat4, glm::vec3(mrb_to_flo(mrb, vals[0]), + mrb_to_flo(mrb, vals[1]), + mrb_to_flo(mrb, vals[2]))); } else { mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong argument count %d (expected 1 or 3)", - len); + "wrong argument count %d (expected 1 or 3)", len); } return target_mat4; } static mrb_value -matrix4_scale(mrb_state *mrb, mrb_value self) +matrix4_scale(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *target_mat4; + Moon::Matrix4* target_mat4; Moon::Matrix4 mat4 = matrix4_scale_m(mrb, self); mrb_value rtarget = mrb_obj_dup(mrb, self); target_mat4 = mmrb_matrix4_ptr(mrb, rtarget); @@ -563,9 +544,9 @@ matrix4_scale(mrb_state *mrb, mrb_value self) }; static mrb_value -matrix4_scale_bang(mrb_state *mrb, mrb_value self) +matrix4_scale_bang(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *target_mat4; + Moon::Matrix4* target_mat4; Moon::Matrix4 mat4 = matrix4_scale_m(mrb, self); target_mat4 = mmrb_matrix4_ptr(mrb, self); *target_mat4 = mat4; @@ -576,9 +557,9 @@ matrix4_scale_bang(mrb_state *mrb, mrb_value self) * @return [Array] */ static mrb_value -matrix4_to_a16(mrb_state *mrb, mrb_value self) +matrix4_to_a16(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *mat4; + Moon::Matrix4* mat4; mat4 = (Moon::Matrix4*)mrb_data_get_ptr(mrb, self, &matrix4_data_type); glm::vec4 row1 = (*mat4)[0]; @@ -587,25 +568,17 @@ matrix4_to_a16(mrb_state *mrb, mrb_value self) glm::vec4 row4 = (*mat4)[3]; mrb_value argv[16] = { - mrb_float_value(mrb, row1[0]), - mrb_float_value(mrb, row1[1]), - mrb_float_value(mrb, row1[2]), - mrb_float_value(mrb, row1[3]), - - mrb_float_value(mrb, row2[0]), - mrb_float_value(mrb, row2[1]), - mrb_float_value(mrb, row2[2]), - mrb_float_value(mrb, row2[3]), - - mrb_float_value(mrb, row3[0]), - mrb_float_value(mrb, row3[1]), - mrb_float_value(mrb, row3[2]), - mrb_float_value(mrb, row3[3]), - - mrb_float_value(mrb, row4[0]), - mrb_float_value(mrb, row4[1]), - mrb_float_value(mrb, row4[2]), - mrb_float_value(mrb, row4[3]) + mrb_float_value(mrb, row1[0]), mrb_float_value(mrb, row1[1]), + mrb_float_value(mrb, row1[2]), mrb_float_value(mrb, row1[3]), + + mrb_float_value(mrb, row2[0]), mrb_float_value(mrb, row2[1]), + mrb_float_value(mrb, row2[2]), mrb_float_value(mrb, row2[3]), + + mrb_float_value(mrb, row3[0]), mrb_float_value(mrb, row3[1]), + mrb_float_value(mrb, row3[2]), mrb_float_value(mrb, row3[3]), + + mrb_float_value(mrb, row4[0]), mrb_float_value(mrb, row4[1]), + mrb_float_value(mrb, row4[2]), mrb_float_value(mrb, row4[3]) }; return mrb_ary_new_from_values(mrb, 16, argv); @@ -615,9 +588,9 @@ matrix4_to_a16(mrb_state *mrb, mrb_value self) * @return [Array] */ static mrb_value -matrix4_to_a(mrb_state *mrb, mrb_value self) +matrix4_to_a(mrb_state* mrb, mrb_value self) { - Moon::Matrix4 *mat4; + Moon::Matrix4* mat4; mat4 = (Moon::Matrix4*)mrb_data_get_ptr(mrb, self, &matrix4_data_type); mrb_value argv[4] = { mmrb_vector4_value(mrb, (*mat4)[0]), mmrb_vector4_value(mrb, (*mat4)[1]), @@ -631,9 +604,9 @@ matrix4_to_a(mrb_state *mrb, mrb_value self) * @return [Matrix4] */ static mrb_value -matrix4_s_cast(mrb_state *mrb, mrb_value self) +matrix4_s_cast(mrb_state* mrb, mrb_value self) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); @@ -652,64 +625,82 @@ matrix4_s_cast(mrb_state *mrb, mrb_value self) * @return [Moon::Matrix4] orthographic matrix */ static mrb_value -matrix4_s_ortho(mrb_state *mrb, mrb_value self) +matrix4_s_ortho(mrb_state* mrb, mrb_value self) { mrb_float a, b, c, d, e, f; mrb_get_args(mrb, "ffffff", &a, &b, &c, &d, &e, &f); return mmrb_matrix4_value(mrb, glm::ortho(a, b, c, d, e, f)); } -//static mrb_value s_extract(mrb_state *mrb, mrb_value self) { +// static mrb_value s_extract(mrb_state *mrb, mrb_value self) { // return mrb_nil_value(); //}; MOON_C_API void -mmrb_matrix4_init(mrb_state *mrb) +mmrb_matrix4_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *matrix4_class = mrb_define_class_under(mrb, mod, "Matrix4", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* matrix4_class = + mrb_define_class_under(mrb, mod, "Matrix4", mrb->object_class); MRB_SET_INSTANCE_TT(matrix4_class, MRB_TT_DATA); - mrb_define_method(mrb, matrix4_class, "initialize", matrix4_initialize, MRB_ARGS_ANY()); - mrb_define_method(mrb, matrix4_class, "initialize_copy", matrix4_initialize_copy, MRB_ARGS_REQ(1)); - - mrb_define_method(mrb, matrix4_class, "coerce", matrix4_coerce, MRB_ARGS_REQ(1)); - - mrb_define_method(mrb, matrix4_class, "==", matrix4_eq, MRB_ARGS_REQ(1)); - - mrb_define_method(mrb, matrix4_class, "[]", matrix4_entry_get, MRB_ARGS_ARG(1,1)); - mrb_define_method(mrb, matrix4_class, "[]=", matrix4_entry_set, MRB_ARGS_ARG(2,1)); - - mrb_define_method(mrb, matrix4_class, "-@", matrix4_op_negate, MRB_ARGS_NONE()); - mrb_define_method(mrb, matrix4_class, "+@", matrix4_op_identity, MRB_ARGS_NONE()); - - mrb_define_method(mrb, matrix4_class, "+", matrix4_op_add, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, matrix4_class, "-", matrix4_op_sub, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, matrix4_class, "*", matrix4_op_mul, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, matrix4_class, "/", matrix4_op_div, MRB_ARGS_REQ(1)); - //mrb_define_method(mrb, matrix4_class, "%", op_mod, MRB_ARGS_REQ(1)); - - mrb_define_method(mrb, matrix4_class, "add", matrix4_add, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, matrix4_class, "sub", matrix4_sub, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, matrix4_class, "mul", matrix4_mul, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, matrix4_class, "div", matrix4_div, MRB_ARGS_REQ(1)); - - mrb_define_method(mrb, matrix4_class, "set", matrix4_set, MRB_ARGS_ANY()); - mrb_define_method(mrb, matrix4_class, "clear", matrix4_clear, MRB_ARGS_NONE()); - - mrb_define_method(mrb, matrix4_class, "translate", matrix4_translate, MRB_ARGS_ANY()); - mrb_define_method(mrb, matrix4_class, "rotate", matrix4_rotate, MRB_ARGS_ANY()); - mrb_define_method(mrb, matrix4_class, "scale", matrix4_scale, MRB_ARGS_ANY()); - - mrb_define_method(mrb, matrix4_class, "translate!", matrix4_translate_bang, MRB_ARGS_ANY()); - mrb_define_method(mrb, matrix4_class, "rotate!", matrix4_rotate_bang, MRB_ARGS_ANY()); - mrb_define_method(mrb, matrix4_class, "scale!", matrix4_scale_bang, MRB_ARGS_ANY()); - - mrb_define_method(mrb, matrix4_class, "to_a16", matrix4_to_a16, MRB_ARGS_NONE()); - mrb_define_method(mrb, matrix4_class, "to_a", matrix4_to_a, MRB_ARGS_NONE()); - - mrb_define_class_method(mrb, matrix4_class, "[]", matrix4_s_cast, MRB_ARGS_ANY()); - mrb_define_class_method(mrb, matrix4_class, "ortho", matrix4_s_ortho, MRB_ARGS_REQ(6)); - //mrb_define_class_method(mrb, matrix4_class, "extract", matrix4_s_extract, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "initialize", matrix4_initialize, + MRB_ARGS_ANY()); + mrb_define_method(mrb, matrix4_class, "initialize_copy", + matrix4_initialize_copy, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, matrix4_class, "coerce", matrix4_coerce, + MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, matrix4_class, "==", matrix4_eq, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, matrix4_class, "[]", matrix4_entry_get, + MRB_ARGS_ARG(1, 1)); + mrb_define_method(mrb, matrix4_class, "[]=", matrix4_entry_set, + MRB_ARGS_ARG(2, 1)); + + mrb_define_method(mrb, matrix4_class, "-@", matrix4_op_negate, + MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix4_class, "+@", matrix4_op_identity, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, matrix4_class, "+", matrix4_op_add, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "-", matrix4_op_sub, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "*", matrix4_op_mul, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "/", matrix4_op_div, MRB_ARGS_REQ(1)); + // mrb_define_method(mrb, matrix4_class, "%", op_mod, + // MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, matrix4_class, "add", matrix4_add, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "sub", matrix4_sub, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "mul", matrix4_mul, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix4_class, "div", matrix4_div, MRB_ARGS_REQ(1)); + + mrb_define_method(mrb, matrix4_class, "set", matrix4_set, MRB_ARGS_ANY()); + mrb_define_method(mrb, matrix4_class, "clear", matrix4_clear, + MRB_ARGS_NONE()); + + mrb_define_method(mrb, matrix4_class, "translate", matrix4_translate, + MRB_ARGS_ANY()); + mrb_define_method(mrb, matrix4_class, "rotate", matrix4_rotate, + MRB_ARGS_ANY()); + mrb_define_method(mrb, matrix4_class, "scale", matrix4_scale, MRB_ARGS_ANY()); + + mrb_define_method(mrb, matrix4_class, "translate!", matrix4_translate_bang, + MRB_ARGS_ANY()); + mrb_define_method(mrb, matrix4_class, "rotate!", matrix4_rotate_bang, + MRB_ARGS_ANY()); + mrb_define_method(mrb, matrix4_class, "scale!", matrix4_scale_bang, + MRB_ARGS_ANY()); + + mrb_define_method(mrb, matrix4_class, "to_a16", matrix4_to_a16, + MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix4_class, "to_a", matrix4_to_a, MRB_ARGS_NONE()); + + mrb_define_class_method(mrb, matrix4_class, "[]", matrix4_s_cast, + MRB_ARGS_ANY()); + mrb_define_class_method(mrb, matrix4_class, "ortho", matrix4_s_ortho, + MRB_ARGS_REQ(6)); + // mrb_define_class_method(mrb, matrix4_class, "extract", matrix4_s_extract, + // MRB_ARGS_REQ(1)); } - diff --git a/modules/system/src/mrb_rect.cxx b/modules/system/src/mrb_rect.cxx index 5cb8400..7ee2c3b 100644 --- a/modules/system/src/mrb_rect.cxx +++ b/modules/system/src/mrb_rect.cxx @@ -1,3 +1,5 @@ +#include "moon/mrb/rect.hxx" +#include "moon/rect.hxx" #include #include #include @@ -5,51 +7,50 @@ #include #include #include -#include "moon/mrb/rect.hxx" -#include "moon/rect.hxx" static void -rect_free(mrb_state *mrb, void *p) +rect_free(mrb_state* mrb, void* p) { - Moon::IntRect *rect = (Moon::IntRect*)p; + Moon::IntRect* rect = (Moon::IntRect*)p; if (rect) { - delete(rect); + delete (rect); } } -MOON_C_API const struct mrb_data_type rect_data_type = { "Moon::IntRect", rect_free }; +MOON_C_API const struct mrb_data_type rect_data_type = { "Moon::IntRect", + rect_free }; static inline void -cleanup_rect(mrb_state *mrb, mrb_value self) +cleanup_rect(mrb_state* mrb, mrb_value self) { - void *ptr = DATA_PTR(self); + void* ptr = DATA_PTR(self); if (ptr) { rect_free(mrb, ptr); } } MOON_C_API Moon::IntRect -mmrb_to_rect(mrb_state *mrb, mrb_value self) +mmrb_to_rect(mrb_state* mrb, mrb_value self) { const mrb_vtype type = mrb_type(self); switch (type) { case MRB_TT_DATA: { - Moon::IntRect *rect = static_cast(mrb_data_check_get_ptr(mrb, self, &rect_data_type)); - if (rect) return *rect; + Moon::IntRect* rect = static_cast( + mrb_data_check_get_ptr(mrb, self, &rect_data_type)); + if (rect) + return *rect; }; break; case MRB_TT_ARRAY: { mrb_int alen = mrb_ary_len(mrb, self); if (alen != 4) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong Array size %S (expected %S)", - mrb_fixnum_to_str(mrb, mrb_fixnum_value(alen), 10), mrb_str_new_cstr(mrb, "4")); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong Array size %S (expected %S)", + mrb_fixnum_to_str(mrb, mrb_fixnum_value(alen), 10), + mrb_str_new_cstr(mrb, "4")); } else { - return Moon::IntRect( - mrb_int(mrb, mrb_ary_entry(self, 0)), - mrb_int(mrb, mrb_ary_entry(self, 1)), - mrb_int(mrb, mrb_ary_entry(self, 2)), - mrb_int(mrb, mrb_ary_entry(self, 3)) - ); + return Moon::IntRect(mrb_int(mrb, mrb_ary_entry(self, 0)), + mrb_int(mrb, mrb_ary_entry(self, 1)), + mrb_int(mrb, mrb_ary_entry(self, 2)), + mrb_int(mrb, mrb_ary_entry(self, 3))); } }; break; case MRB_TT_FIXNUM: @@ -61,31 +62,31 @@ mmrb_to_rect(mrb_state *mrb, mrb_value self) break; } mrb_raise(mrb, E_TYPE_ERROR, "unexpected type"); - return Moon::IntRect{0, 0, 0, 0}; + return Moon::IntRect{ 0, 0, 0, 0 }; } MOON_C_API Moon::FloatRect -mmrb_to_float_rect(mrb_state *mrb, mrb_value obj) +mmrb_to_float_rect(mrb_state* mrb, mrb_value obj) { const mrb_vtype type = mrb_type(obj); switch (type) { case MRB_TT_DATA: { - Moon::IntRect *rect = static_cast(mrb_data_check_get_ptr(mrb, obj, &rect_data_type)); - if (rect) return Moon::FloatRect(rect->x, rect->y, rect->w, rect->h); + Moon::IntRect* rect = static_cast( + mrb_data_check_get_ptr(mrb, obj, &rect_data_type)); + if (rect) + return Moon::FloatRect(rect->x, rect->y, rect->w, rect->h); }; break; case MRB_TT_ARRAY: { mrb_int alen = mrb_ary_len(mrb, obj); if (alen != 4) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong Array size %S (expected %S)", - mrb_fixnum_to_str(mrb, mrb_fixnum_value(alen), 10), mrb_str_new_cstr(mrb, "4")); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong Array size %S (expected %S)", + mrb_fixnum_to_str(mrb, mrb_fixnum_value(alen), 10), + mrb_str_new_cstr(mrb, "4")); } else { - return Moon::FloatRect( - mrb_to_flo(mrb, mrb_ary_entry(obj, 0)), - mrb_to_flo(mrb, mrb_ary_entry(obj, 1)), - mrb_to_flo(mrb, mrb_ary_entry(obj, 2)), - mrb_to_flo(mrb, mrb_ary_entry(obj, 3)) - ); + return Moon::FloatRect(mrb_to_flo(mrb, mrb_ary_entry(obj, 0)), + mrb_to_flo(mrb, mrb_ary_entry(obj, 1)), + mrb_to_flo(mrb, mrb_ary_entry(obj, 2)), + mrb_to_flo(mrb, mrb_ary_entry(obj, 3))); } }; break; case MRB_TT_FIXNUM: @@ -97,13 +98,13 @@ mmrb_to_float_rect(mrb_state *mrb, mrb_value obj) break; } mrb_raise(mrb, E_TYPE_ERROR, "unexpected type"); - return Moon::FloatRect{0, 0, 0, 0}; + return Moon::FloatRect{ 0, 0, 0, 0 }; } MOON_C_API mrb_value -mmrb_rect_value(mrb_state *mrb, Moon::IntRect rect) +mmrb_rect_value(mrb_state* mrb, Moon::IntRect rect) { - Moon::IntRect *target; + Moon::IntRect* target; mrb_value result; result = mrb_obj_new(mrb, mmrb_get_rect_class(mrb), 0, NULL); target = mmrb_rect_ptr(mrb, result); @@ -119,10 +120,10 @@ mmrb_rect_value(mrb_state *mrb, Moon::IntRect rect) * @return [Rect] */ static mrb_value -rect_initialize(mrb_state *mrb, mrb_value self) +rect_initialize(mrb_state* mrb, mrb_value self) { mrb_int x = 0, y = 0, w = 0, h = 0; - Moon::IntRect *rect; + Moon::IntRect* rect; mrb_get_args(mrb, "|iiii", &x, &y, &w, &h); cleanup_rect(mrb, self); rect = new Moon::IntRect(x, y, w, h); @@ -137,9 +138,9 @@ rect_initialize(mrb_state *mrb, mrb_value self) * @return [self] */ static mrb_value -rect_initialize_copy(mrb_state *mrb, mrb_value self) +rect_initialize_copy(mrb_state* mrb, mrb_value self) { - Moon::IntRect *other; + Moon::IntRect* other; mrb_get_args(mrb, "d", &other, &rect_data_type); cleanup_rect(mrb, self); mrb_data_init(self, new Moon::IntRect(*other), &rect_data_type); @@ -147,7 +148,7 @@ rect_initialize_copy(mrb_state *mrb, mrb_value self) } static mrb_value -rect_set_x(mrb_state *mrb, mrb_value self) +rect_set_x(mrb_state* mrb, mrb_value self) { mrb_int x; mrb_get_args(mrb, "i", &x); @@ -156,13 +157,13 @@ rect_set_x(mrb_state *mrb, mrb_value self) } static mrb_value -rect_get_x(mrb_state *mrb, mrb_value self) +rect_get_x(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_rect_ptr(mrb, self)->x); } static mrb_value -rect_set_y(mrb_state *mrb, mrb_value self) +rect_set_y(mrb_state* mrb, mrb_value self) { mrb_int y; mrb_get_args(mrb, "i", &y); @@ -171,13 +172,13 @@ rect_set_y(mrb_state *mrb, mrb_value self) } static mrb_value -rect_get_y(mrb_state *mrb, mrb_value self) +rect_get_y(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_rect_ptr(mrb, self)->y); } static mrb_value -rect_set_w(mrb_state *mrb, mrb_value self) +rect_set_w(mrb_state* mrb, mrb_value self) { mrb_int w; mrb_get_args(mrb, "i", &w); @@ -186,13 +187,13 @@ rect_set_w(mrb_state *mrb, mrb_value self) } static mrb_value -rect_get_w(mrb_state *mrb, mrb_value self) +rect_get_w(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_rect_ptr(mrb, self)->w); } static mrb_value -rect_set_h(mrb_state *mrb, mrb_value self) +rect_set_h(mrb_state* mrb, mrb_value self) { mrb_int h; mrb_get_args(mrb, "i", &h); @@ -201,26 +202,29 @@ rect_set_h(mrb_state *mrb, mrb_value self) } static mrb_value -rect_get_h(mrb_state *mrb, mrb_value self) +rect_get_h(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value(mmrb_rect_ptr(mrb, self)->h); } MOON_C_API void -mmrb_rect_init(mrb_state *mrb) +mmrb_rect_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *rect_class = mrb_define_class_under(mrb, mod, "Rect", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* rect_class = + mrb_define_class_under(mrb, mod, "Rect", mrb->object_class); MRB_SET_INSTANCE_TT(rect_class, MRB_TT_DATA); - mrb_define_method(mrb, rect_class, "initialize", rect_initialize, MRB_ARGS_ARG(0,4)); - mrb_define_method(mrb, rect_class, "initialize_copy", rect_initialize_copy, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rect_class, "x=", rect_set_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rect_class, "x", rect_get_x, MRB_ARGS_NONE()); - mrb_define_method(mrb, rect_class, "y=", rect_set_y, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rect_class, "y", rect_get_y, MRB_ARGS_NONE()); - mrb_define_method(mrb, rect_class, "w=", rect_set_w, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rect_class, "w", rect_get_w, MRB_ARGS_NONE()); - mrb_define_method(mrb, rect_class, "h=", rect_set_h, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rect_class, "h", rect_get_h, MRB_ARGS_NONE()); + mrb_define_method(mrb, rect_class, "initialize", rect_initialize, + MRB_ARGS_ARG(0, 4)); + mrb_define_method(mrb, rect_class, "initialize_copy", rect_initialize_copy, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rect_class, "x=", rect_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rect_class, "x", rect_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, rect_class, "y=", rect_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rect_class, "y", rect_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, rect_class, "w=", rect_set_w, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rect_class, "w", rect_get_w, MRB_ARGS_NONE()); + mrb_define_method(mrb, rect_class, "h=", rect_set_h, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rect_class, "h", rect_get_h, MRB_ARGS_NONE()); } diff --git a/modules/system/src/mrb_system.cxx b/modules/system/src/mrb_system.cxx index 1f0e666..f52ffe8 100644 --- a/modules/system/src/mrb_system.cxx +++ b/modules/system/src/mrb_system.cxx @@ -1,20 +1,20 @@ -#include -#include -#include -#include #include "moon/mrb/clock.hxx" #include "moon/mrb/context.hxx" -#include "moon/mrb/rect.hxx" #include "moon/mrb/matrix4.hxx" +#include "moon/mrb/rect.hxx" #include "moon/mrb/vector1.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" +#include +#include +#include +#include extern "C" void mrb_mruby_moon_system_gem_init(mrb_state* mrb) { - struct RClass *moon_module = mrb_define_module(mrb, "Moon"); + struct RClass* moon_module = mrb_define_module(mrb, "Moon"); mmrb_clock_init(mrb); mmrb_rect_init(mrb); mmrb_vector1_init(mrb); diff --git a/modules/system/src/mrb_vector1.cxx b/modules/system/src/mrb_vector1.cxx index d542bcd..d1706f0 100644 --- a/modules/system/src/mrb_vector1.cxx +++ b/modules/system/src/mrb_vector1.cxx @@ -1,48 +1,53 @@ /* * Moon Vector1, a wrapper around glm::vec1 */ +#include "moon/mrb/vector1.hxx" +#include "vec_helper.h" #include #include #include #include #include -#include "moon/mrb/vector1.hxx" -#include "vec_helper.h" -#define m_vector_operator(__op__) \ - return mmrb_vector1_value(mrb, get_vector1_value(mrb, self) __op__ vector1_from_mrb_args(mrb)); +#define m_vector_operator(__op__) \ + return mmrb_vector1_value(mrb, get_vector1_value(mrb, self) \ + __op__ vector1_from_mrb_args(mrb)); -#define m_vector_int_operator(__op__) \ - return mmrb_vector1_value(mrb, Moon::Vector1(Moon::Vector1i(get_vector1_value(mrb, self)) __op__ Moon::Vector1i(vector1_from_mrb_args(mrb)))); +#define m_vector_int_operator(__op__) \ + return mmrb_vector1_value( \ + mrb, Moon::Vector1(Moon::Vector1i(get_vector1_value(mrb, self)) \ + __op__ Moon::Vector1i(vector1_from_mrb_args(mrb)))); static void -vector1_free(mrb_state *mrb, void *p) +vector1_free(mrb_state* mrb, void* p) { - Moon::Vector1 *vec = (Moon::Vector1*)p; + Moon::Vector1* vec = (Moon::Vector1*)p; if (vec) { - delete(vec); + delete (vec); } } -MOON_C_API const struct mrb_data_type vector1_data_type = { "Moon::Vector1", vector1_free }; +MOON_C_API const struct mrb_data_type vector1_data_type = { "Moon::Vector1", + vector1_free }; -DEF_VEC_HELPERS(vector1, Moon::Vector1, mmrb_get_vector1_class(mrb), &vector1_data_type); +DEF_VEC_HELPERS(vector1, Moon::Vector1, mmrb_get_vector1_class(mrb), + &vector1_data_type); static Moon::Vector1 -mmrb_vector1_extract_mrb_num(mrb_state *mrb, mrb_value obj) +mmrb_vector1_extract_mrb_num(mrb_state* mrb, mrb_value obj) { double i = mmrb_to_flo(mrb, obj); return Moon::Vector1(i); } static Moon::Vector1 -mmrb_vector1_extract_mrb_array(mrb_state *mrb, mrb_value obj) +mmrb_vector1_extract_mrb_array(mrb_state* mrb, mrb_value obj) { Moon::Vector1 result; int _ary_len = mrb_ary_len(mrb, obj); if (_ary_len != 1) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong array size %d (expected 1)", _ary_len); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong array size %d (expected 1)", + _ary_len); } else { result.x = mrb_to_flo(mrb, RARRAY_PTR(obj)[0]); } @@ -50,67 +55,67 @@ mmrb_vector1_extract_mrb_array(mrb_state *mrb, mrb_value obj) } static Moon::Vector1 -mmrb_vector1_extract_mrb_to_vec1(mrb_state *mrb, mrb_value obj) +mmrb_vector1_extract_mrb_to_vec1(mrb_state* mrb, mrb_value obj) { return get_vector1_value(mrb, mrb_funcall(mrb, obj, "to_vec1", 0)); } static Moon::Vector1 -mmrb_vector1_extract_args(mrb_state *mrb, int argc, mrb_value *vals) +mmrb_vector1_extract_args(mrb_state* mrb, int argc, mrb_value* vals) { Moon::Vector1 result; switch (argc) { - case 1: - mrb_value val; - val = vals[0]; - switch (mrb_type(val)) { - case MRB_TT_FIXNUM: - case MRB_TT_FLOAT: - result = mmrb_vector1_extract_mrb_num(mrb, val); - break; - case MRB_TT_ARRAY: - result = mmrb_vector1_extract_mrb_array(mrb, val); - break; - case MRB_TT_DATA: - if (DATA_TYPE(val) == &vector1_data_type) { - result = get_vector1_value(mrb, val); - break; + case 1: + mrb_value val; + val = vals[0]; + switch (mrb_type(val)) { + case MRB_TT_FIXNUM: + case MRB_TT_FLOAT: + result = mmrb_vector1_extract_mrb_num(mrb, val); + break; + case MRB_TT_ARRAY: + result = mmrb_vector1_extract_mrb_array(mrb, val); + break; + case MRB_TT_DATA: + if (DATA_TYPE(val) == &vector1_data_type) { + result = get_vector1_value(mrb, val); + break; + } + default: + if (mrb_respond_to(mrb, val, mrb_intern_cstr(mrb, "to_vec1"))) { + result = mmrb_vector1_extract_mrb_to_vec1(mrb, val); + break; + } else { + mrb_raisef(mrb, E_TYPE_ERROR, + "wrong type %S (expected Numeric, Array or Vector1)", + mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, val))); + } } + break; default: - if (mrb_respond_to(mrb, val, mrb_intern_cstr(mrb, "to_vec1"))) { - result = mmrb_vector1_extract_mrb_to_vec1(mrb, val); - break; - } else { - mrb_raisef(mrb, E_TYPE_ERROR, - "wrong type %S (expected Numeric, Array or Vector1)", - mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, val))); - } - } - break; - default: - mrb_raisef(mrb, E_ARGUMENT_ERROR, - "wrong number of arguments (%d for 1)", argc); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", + argc); } return result; } static Moon::Vector1 -vector1_from_mrb_args(mrb_state *mrb) +vector1_from_mrb_args(mrb_state* mrb) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); return mmrb_vector1_extract_args(mrb, len, vals); } MOON_C_API Moon::Vector1 -mmrb_to_vector1(mrb_state *mrb, mrb_value obj) +mmrb_to_vector1(mrb_state* mrb, mrb_value obj) { return mmrb_vector1_extract_args(mrb, 1, &obj); } MOON_C_API mrb_value -mmrb_vector1_value(mrb_state *mrb, Moon::Vector1 vec) +mmrb_vector1_value(mrb_state* mrb, Moon::Vector1 vec) { return set_vector1(mrb, new_vector1(mrb), vec); } @@ -122,7 +127,7 @@ mmrb_vector1_value(mrb_state *mrb, Moon::Vector1 vec) * @return [self] */ static mrb_value -vector1_initialize(mrb_state *mrb, mrb_value self) +vector1_initialize(mrb_state* mrb, mrb_value self) { mrb_float x = 0.0; mrb_get_args(mrb, "|f", &x); @@ -133,10 +138,11 @@ vector1_initialize(mrb_state *mrb, mrb_value self) // @return [self] static mrb_value -vector1_initialize_copy(mrb_state *mrb, mrb_value self) +vector1_initialize_copy(mrb_state* mrb, mrb_value self) { cleanup_vector1(mrb, self); - mrb_data_init(self, new Moon::Vector1(vector1_from_mrb_args(mrb)), &vector1_data_type); + mrb_data_init(self, new Moon::Vector1(vector1_from_mrb_args(mrb)), + &vector1_data_type); return self; } @@ -148,7 +154,7 @@ vector1_initialize_copy(mrb_state *mrb, mrb_value self) * @api private */ static mrb_value -vector1_coerce(mrb_state *mrb, mrb_value self) +vector1_coerce(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); @@ -162,12 +168,13 @@ vector1_coerce(mrb_state *mrb, mrb_value self) * @return [Boolean] */ static mrb_value -vector1_eq(mrb_state *mrb, mrb_value self) +vector1_eq(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); if (mrb_obj_is_kind_of(mrb, other, mmrb_get_vector1_class(mrb))) { - return mrb_bool_value((*mmrb_vector1_ptr(mrb, self)) == (*mmrb_vector1_ptr(mrb, other))); + return mrb_bool_value((*mmrb_vector1_ptr(mrb, self)) == + (*mmrb_vector1_ptr(mrb, other))); } return mrb_bool_value(false); } @@ -176,7 +183,7 @@ vector1_eq(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector1_x_getter(mrb_state *mrb, mrb_value self) +vector1_x_getter(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector1_ptr(mrb, self)->x); } @@ -186,7 +193,7 @@ vector1_x_getter(mrb_state *mrb, mrb_value self) * @return [nil] */ static mrb_value -vector1_x_setter(mrb_state *mrb, mrb_value self) +vector1_x_setter(mrb_state* mrb, mrb_value self) { mrb_float x; mrb_get_args(mrb, "f", &x); @@ -200,7 +207,7 @@ vector1_x_setter(mrb_state *mrb, mrb_value self) * @return [Vector1] */ static mrb_value -vector1_negate(mrb_state *mrb, mrb_value self) +vector1_negate(mrb_state* mrb, mrb_value self) { return mmrb_vector1_value(mrb, -get_vector1_value(mrb, self)); } @@ -211,31 +218,31 @@ vector1_negate(mrb_state *mrb, mrb_value self) * @return [Vector1] */ static mrb_value -vector1_identity(mrb_state *mrb, mrb_value self) +vector1_identity(mrb_state* mrb, mrb_value self) { return self; } static mrb_value -vector1_add(mrb_state *mrb, mrb_value self) +vector1_add(mrb_state* mrb, mrb_value self) { m_vector_operator(+); } static mrb_value -vector1_sub(mrb_state *mrb, mrb_value self) +vector1_sub(mrb_state* mrb, mrb_value self) { m_vector_operator(-); } static mrb_value -vector1_mul(mrb_state *mrb, mrb_value self) +vector1_mul(mrb_state* mrb, mrb_value self) { m_vector_operator(*); } static mrb_value -vector1_div(mrb_state *mrb, mrb_value self) +vector1_div(mrb_state* mrb, mrb_value self) { m_vector_operator(/); } @@ -246,58 +253,60 @@ vector1_div(mrb_state *mrb, mrb_value self) * @return [Vector1] */ static mrb_value -vector1_not(mrb_state *mrb, mrb_value self) +vector1_not(mrb_state* mrb, mrb_value self) { - return mmrb_vector1_value(mrb, Moon::Vector1(~(Moon::Vector1i(*mmrb_vector1_ptr(mrb, self))))); + return mmrb_vector1_value( + mrb, Moon::Vector1(~(Moon::Vector1i(*mmrb_vector1_ptr(mrb, self))))); } static mrb_value -vector1_modulo(mrb_state *mrb, mrb_value self) +vector1_modulo(mrb_state* mrb, mrb_value self) { m_vector_int_operator(%); } static mrb_value -vector1_shl(mrb_state *mrb, mrb_value self) +vector1_shl(mrb_state* mrb, mrb_value self) { m_vector_int_operator(<<); } static mrb_value -vector1_shr(mrb_state *mrb, mrb_value self) +vector1_shr(mrb_state* mrb, mrb_value self) { m_vector_int_operator(>>); } static mrb_value -vector1_and(mrb_state *mrb, mrb_value self) +vector1_and(mrb_state* mrb, mrb_value self) { m_vector_int_operator(&); } static mrb_value -vector1_or(mrb_state *mrb, mrb_value self) +vector1_or(mrb_state* mrb, mrb_value self) { m_vector_int_operator(|); } static mrb_value -vector1_xor(mrb_state *mrb, mrb_value self) +vector1_xor(mrb_state* mrb, mrb_value self) { - m_vector_int_operator(^); + m_vector_int_operator (^); } static mrb_value -vector1_dot(mrb_state *mrb, mrb_value self) +vector1_dot(mrb_state* mrb, mrb_value self) { - return mrb_float_value(mrb, glm::dot(get_vector1_value(mrb, self), vector1_from_mrb_args(mrb))); + return mrb_float_value( + mrb, glm::dot(get_vector1_value(mrb, self), vector1_from_mrb_args(mrb))); } /* Returns a vector in the same direction, but with length of 1. * @return [Vector1] */ static mrb_value -vector1_normalize(mrb_state *mrb, mrb_value self) +vector1_normalize(mrb_state* mrb, mrb_value self) { return mmrb_vector1_value(mrb, glm::normalize(get_vector1_value(mrb, self))); } @@ -306,7 +315,7 @@ vector1_normalize(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector1_length(mrb_state *mrb, mrb_value self) +vector1_length(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, glm::length(get_vector1_value(mrb, self))); } @@ -316,11 +325,12 @@ vector1_length(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector1_distance(mrb_state *mrb, mrb_value self) +vector1_distance(mrb_state* mrb, mrb_value self) { - Moon::Vector1 *other; + Moon::Vector1* other; mrb_get_args(mrb, "d", &other, &vector1_data_type); - return mrb_float_value(mrb, glm::distance(get_vector1_value(mrb, self), *other)); + return mrb_float_value(mrb, + glm::distance(get_vector1_value(mrb, self), *other)); } /* Linear interpolation of two quaternions. @@ -328,20 +338,23 @@ vector1_distance(mrb_state *mrb, mrb_value self) * The interpolation is oriented. * * @param [Vector1] other quaternion - * @param [Float] delta Interpolation factor. The interpolation is defined in the range [0, 1]. + * @param [Float] delta Interpolation factor. The interpolation is defined in + * the range [0, 1]. * @return [Vector1] */ static mrb_value -vector1_lerp(mrb_state *mrb, mrb_value self) +vector1_lerp(mrb_state* mrb, mrb_value self) { - Moon::Vector1 *other; + Moon::Vector1* other; mrb_float delta; mrb_get_args(mrb, "df", &other, &vector1_data_type, &delta); - return mmrb_vector1_value(mrb, Moon::Vector1(glm::lerp(mmrb_vector1_ptr(mrb, self)->x, other->x, (float)delta))); + return mmrb_vector1_value( + mrb, Moon::Vector1( + glm::lerp(mmrb_vector1_ptr(mrb, self)->x, other->x, (float)delta))); } static mrb_value -vector1_set(mrb_state *mrb, mrb_value self) +vector1_set(mrb_state* mrb, mrb_value self) { return set_vector1(mrb, self, vector1_from_mrb_args(mrb)); } @@ -350,7 +363,7 @@ vector1_set(mrb_state *mrb, mrb_value self) * @return [Integer] */ static mrb_value -vector1_to_int(mrb_state *mrb, mrb_value self) +vector1_to_int(mrb_state* mrb, mrb_value self) { return mrb_fixnum_value((mrb_int)mmrb_vector1_ptr(mrb, self)->x); } @@ -359,7 +372,7 @@ vector1_to_int(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector1_to_f(mrb_state *mrb, mrb_value self) +vector1_to_f(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, (mrb_float)mmrb_vector1_ptr(mrb, self)->x); } @@ -370,14 +383,14 @@ vector1_to_f(mrb_state *mrb, mrb_value self) * @return [Array] */ static mrb_value -vector1_to_a(mrb_state *mrb, mrb_value self) +vector1_to_a(mrb_state* mrb, mrb_value self) { mrb_value argv[1] = { mrb_float_value(mrb, mmrb_vector1_ptr(mrb, self)->x) }; return mrb_ary_new_from_values(mrb, 1, argv); } static mrb_value -vector1_s_extract(mrb_state *mrb, mrb_value self) +vector1_s_extract(mrb_state* mrb, mrb_value self) { Moon::Vector1 src_vect = vector1_from_mrb_args(mrb); mrb_value argv[1] = { mrb_float_value(mrb, src_vect.x) }; @@ -385,56 +398,69 @@ vector1_s_extract(mrb_state *mrb, mrb_value self) } static mrb_value -vector1_s_cast(mrb_state *mrb, mrb_value klass) +vector1_s_cast(mrb_state* mrb, mrb_value klass) { return set_vector1(mrb, new_vector1(mrb), vector1_from_mrb_args(mrb)); } MOON_C_API void -mmrb_vector1_init(mrb_state *mrb) +mmrb_vector1_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *vector1_class = mrb_define_class_under(mrb, mod, "Vector1", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* vector1_class = + mrb_define_class_under(mrb, mod, "Vector1", mrb->object_class); MRB_SET_INSTANCE_TT(vector1_class, MRB_TT_DATA); - mrb_define_method(mrb, vector1_class, "initialize", vector1_initialize, MRB_ARGS_OPT(1)); - mrb_define_method(mrb, vector1_class, "initialize_copy", vector1_initialize_copy, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "initialize", vector1_initialize, + MRB_ARGS_OPT(1)); + mrb_define_method(mrb, vector1_class, "initialize_copy", + vector1_initialize_copy, MRB_ARGS_REQ(1)); /* coercion */ - mrb_define_method(mrb, vector1_class, "coerce", vector1_coerce, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "==", vector1_eq, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "coerce", vector1_coerce, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "==", vector1_eq, MRB_ARGS_REQ(1)); /* attribute setters */ // @!attribute [rw] x // @return [Integer] x coordinate - mrb_define_method(mrb, vector1_class, "x", vector1_x_getter, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "x=", vector1_x_setter, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "set", vector1_set, MRB_ARGS_ANY()); + mrb_define_method(mrb, vector1_class, "x", vector1_x_getter, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "x=", vector1_x_setter, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "set", vector1_set, MRB_ARGS_ANY()); /* arithmetic */ - mrb_define_method(mrb, vector1_class, "-@", vector1_negate, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "+@", vector1_identity, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "+", vector1_add, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "-", vector1_sub, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "*", vector1_mul, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "/", vector1_div, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "dot", vector1_dot, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "-@", vector1_negate, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "+@", vector1_identity, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "+", vector1_add, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "-", vector1_sub, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "*", vector1_mul, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "/", vector1_div, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "dot", vector1_dot, MRB_ARGS_REQ(1)); /* */ - mrb_define_method(mrb, vector1_class, "normalize", vector1_normalize, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "length", vector1_length, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "distance", vector1_distance, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "lerp", vector1_lerp, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, vector1_class, "normalize", vector1_normalize, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "length", vector1_length, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "distance", vector1_distance, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "lerp", vector1_lerp, MRB_ARGS_REQ(2)); /* bitwise operators */ - mrb_define_method(mrb, vector1_class, "~@", vector1_not, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "%", vector1_modulo, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "<<", vector1_shl, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, ">>", vector1_shr, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "&", vector1_and, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "|", vector1_or, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector1_class, "^", vector1_xor, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "~@", vector1_not, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "%", vector1_modulo, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "<<", vector1_shl, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, ">>", vector1_shr, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "&", vector1_and, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "|", vector1_or, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector1_class, "^", vector1_xor, MRB_ARGS_REQ(1)); /* conversion */ - mrb_define_method(mrb, vector1_class, "to_int", vector1_to_int, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "to_i", vector1_to_int, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "to_f", vector1_to_f, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector1_class, "to_a", vector1_to_a, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "to_int", vector1_to_int, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "to_i", vector1_to_int, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "to_f", vector1_to_f, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector1_class, "to_a", vector1_to_a, MRB_ARGS_NONE()); /* cast */ - mrb_define_class_method(mrb, vector1_class, "[]", vector1_s_cast, MRB_ARGS_ANY()); - mrb_define_class_method(mrb, vector1_class, "extract", vector1_s_extract, MRB_ARGS_REQ(1)); + mrb_define_class_method(mrb, vector1_class, "[]", vector1_s_cast, + MRB_ARGS_ANY()); + mrb_define_class_method(mrb, vector1_class, "extract", vector1_s_extract, + MRB_ARGS_REQ(1)); } diff --git a/modules/system/src/mrb_vector2.cxx b/modules/system/src/mrb_vector2.cxx index cb59335..a27cd4f 100644 --- a/modules/system/src/mrb_vector2.cxx +++ b/modules/system/src/mrb_vector2.cxx @@ -1,37 +1,42 @@ /* * Moon Vector2, a wrapper around Moon::Vector2 */ +#include "moon/mrb/vector1.hxx" +#include "moon/mrb/vector2.hxx" +#include "moon/mrb/vector_unroll.hxx" +#include "vec_helper.h" #include #include #include #include #include -#include "moon/mrb/vector1.hxx" -#include "moon/mrb/vector2.hxx" -#include "moon/mrb/vector_unroll.hxx" -#include "vec_helper.h" -#define m_vector_operator(__op__) \ - return mmrb_vector2_value(mrb, get_vector2_value(mrb, self) __op__ vector2_from_mrb_args(mrb)); +#define m_vector_operator(__op__) \ + return mmrb_vector2_value(mrb, get_vector2_value(mrb, self) \ + __op__ vector2_from_mrb_args(mrb)); -#define m_vector_int_operator(__op__) \ - return mmrb_vector2_value(mrb, Moon::Vector2(glm::ivec2(get_vector2_value(mrb, self)) __op__ glm::ivec2(vector2_from_mrb_args(mrb)))); +#define m_vector_int_operator(__op__) \ + return mmrb_vector2_value( \ + mrb, Moon::Vector2(glm::ivec2(get_vector2_value(mrb, self)) \ + __op__ glm::ivec2(vector2_from_mrb_args(mrb)))); static void -vector2_free(mrb_state *mrb, void *p) +vector2_free(mrb_state* mrb, void* p) { - Moon::Vector2 *vec2 = (Moon::Vector2*)p; + Moon::Vector2* vec2 = (Moon::Vector2*)p; if (vec2) { - delete(vec2); + delete (vec2); } } -MOON_C_API const struct mrb_data_type vector2_data_type = { "Moon::Vector2", vector2_free }; +MOON_C_API const struct mrb_data_type vector2_data_type = { "Moon::Vector2", + vector2_free }; -DEF_VEC_HELPERS(vector2, Moon::Vector2, mmrb_get_vector2_class(mrb), &vector2_data_type); +DEF_VEC_HELPERS(vector2, Moon::Vector2, mmrb_get_vector2_class(mrb), + &vector2_data_type); static Moon::Vector2 -mmrb_vector2_extract_args(mrb_state *mrb, int argc, mrb_value *vals) +mmrb_vector2_extract_args(mrb_state* mrb, int argc, mrb_value* vals) { mrb_float result[2]; mmrb_vector_unroll(mrb, argc, vals, 2, result); @@ -39,22 +44,22 @@ mmrb_vector2_extract_args(mrb_state *mrb, int argc, mrb_value *vals) } static Moon::Vector2 -vector2_from_mrb_args(mrb_state *mrb) +vector2_from_mrb_args(mrb_state* mrb) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); return mmrb_vector2_extract_args(mrb, len, vals); } MOON_C_API Moon::Vector2 -mmrb_to_vector2(mrb_state *mrb, mrb_value obj) +mmrb_to_vector2(mrb_state* mrb, mrb_value obj) { return mmrb_vector2_extract_args(mrb, 1, &obj); } MOON_C_API mrb_value -mmrb_vector2_value(mrb_state *mrb, Moon::Vector2 vec) +mmrb_vector2_value(mrb_state* mrb, Moon::Vector2 vec) { return set_vector2(mrb, new_vector2(mrb), vec); } @@ -67,7 +72,7 @@ mmrb_vector2_value(mrb_state *mrb, Moon::Vector2 vec) * @return [self] */ static mrb_value -vector2_initialize(mrb_state *mrb, mrb_value self) +vector2_initialize(mrb_state* mrb, mrb_value self) { mrb_float x = 0.0; mrb_float y = 0.0; @@ -78,10 +83,11 @@ vector2_initialize(mrb_state *mrb, mrb_value self) } static mrb_value -vector2_initialize_copy(mrb_state *mrb, mrb_value self) +vector2_initialize_copy(mrb_state* mrb, mrb_value self) { cleanup_vector2(mrb, self); - mrb_data_init(self, new Moon::Vector2(vector2_from_mrb_args(mrb)), &vector2_data_type); + mrb_data_init(self, new Moon::Vector2(vector2_from_mrb_args(mrb)), + &vector2_data_type); return self; } @@ -93,7 +99,7 @@ vector2_initialize_copy(mrb_state *mrb, mrb_value self) * @api private */ static mrb_value -vector2_coerce(mrb_state *mrb, mrb_value self) +vector2_coerce(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); @@ -108,30 +114,31 @@ vector2_coerce(mrb_state *mrb, mrb_value self) * @return [Boolean] true other and self are equal, false otherwise */ static mrb_value -vector2_eq(mrb_state *mrb, mrb_value self) +vector2_eq(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); if (mrb_obj_is_kind_of(mrb, other, mmrb_get_vector2_class(mrb))) { - return mrb_bool_value((*mmrb_vector2_ptr(mrb, self)) == (*mmrb_vector2_ptr(mrb, other))); + return mrb_bool_value((*mmrb_vector2_ptr(mrb, self)) == + (*mmrb_vector2_ptr(mrb, other))); } return mrb_bool_value(false); } static mrb_value -vector2_get_x(mrb_state *mrb, mrb_value self) +vector2_get_x(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector2_ptr(mrb, self)->x); } static mrb_value -vector2_get_y(mrb_state *mrb, mrb_value self) +vector2_get_y(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector2_ptr(mrb, self)->y); } static mrb_value -vector2_set_x(mrb_state *mrb, mrb_value self) +vector2_set_x(mrb_state* mrb, mrb_value self) { mrb_float x; mrb_get_args(mrb, "f", &x); @@ -140,7 +147,7 @@ vector2_set_x(mrb_state *mrb, mrb_value self) } static mrb_value -vector2_set_y(mrb_state *mrb, mrb_value self) +vector2_set_y(mrb_state* mrb, mrb_value self) { mrb_float y; mrb_get_args(mrb, "f", &y); @@ -154,7 +161,7 @@ vector2_set_y(mrb_state *mrb, mrb_value self) * @return [Vector2] */ static mrb_value -vector2_negate(mrb_state *mrb, mrb_value self) +vector2_negate(mrb_state* mrb, mrb_value self) { return mmrb_vector2_value(mrb, -get_vector2_value(mrb, self)); } @@ -165,31 +172,31 @@ vector2_negate(mrb_state *mrb, mrb_value self) * @return [Vector2] */ static mrb_value -vector2_identity(mrb_state *mrb, mrb_value self) +vector2_identity(mrb_state* mrb, mrb_value self) { return mrb_obj_dup(mrb, self); } static mrb_value -vector2_add(mrb_state *mrb, mrb_value self) +vector2_add(mrb_state* mrb, mrb_value self) { m_vector_operator(+); } static mrb_value -vector2_sub(mrb_state *mrb, mrb_value self) +vector2_sub(mrb_state* mrb, mrb_value self) { m_vector_operator(-); } static mrb_value -vector2_mul(mrb_state *mrb, mrb_value self) +vector2_mul(mrb_state* mrb, mrb_value self) { m_vector_operator(*); } static mrb_value -vector2_div(mrb_state *mrb, mrb_value self) +vector2_div(mrb_state* mrb, mrb_value self) { m_vector_operator(/); } @@ -200,58 +207,60 @@ vector2_div(mrb_state *mrb, mrb_value self) * @return [Vector2] */ static mrb_value -vector2_not(mrb_state *mrb, mrb_value self) +vector2_not(mrb_state* mrb, mrb_value self) { - return mmrb_vector2_value(mrb, Moon::Vector2(~(glm::ivec2(*mmrb_vector2_ptr(mrb, self))))); + return mmrb_vector2_value( + mrb, Moon::Vector2(~(glm::ivec2(*mmrb_vector2_ptr(mrb, self))))); } static mrb_value -vector2_modulo(mrb_state *mrb, mrb_value self) +vector2_modulo(mrb_state* mrb, mrb_value self) { m_vector_int_operator(%); } static mrb_value -vector2_shl(mrb_state *mrb, mrb_value self) +vector2_shl(mrb_state* mrb, mrb_value self) { m_vector_int_operator(<<); } static mrb_value -vector2_shr(mrb_state *mrb, mrb_value self) +vector2_shr(mrb_state* mrb, mrb_value self) { m_vector_int_operator(>>); } static mrb_value -vector2_and(mrb_state *mrb, mrb_value self) +vector2_and(mrb_state* mrb, mrb_value self) { m_vector_int_operator(&); } static mrb_value -vector2_or(mrb_state *mrb, mrb_value self) +vector2_or(mrb_state* mrb, mrb_value self) { m_vector_int_operator(|); } static mrb_value -vector2_xor(mrb_state *mrb, mrb_value self) +vector2_xor(mrb_state* mrb, mrb_value self) { - m_vector_int_operator(^); + m_vector_int_operator (^); } static mrb_value -vector2_dot(mrb_state *mrb, mrb_value self) +vector2_dot(mrb_state* mrb, mrb_value self) { - return mrb_float_value(mrb, glm::dot(get_vector2_value(mrb, self), vector2_from_mrb_args(mrb))); + return mrb_float_value( + mrb, glm::dot(get_vector2_value(mrb, self), vector2_from_mrb_args(mrb))); } /* Returns a vector in the same direction, but with length of 1. * @return [Vector2] */ static mrb_value -vector2_normalize(mrb_state *mrb, mrb_value self) +vector2_normalize(mrb_state* mrb, mrb_value self) { return mmrb_vector2_value(mrb, glm::normalize(get_vector2_value(mrb, self))); } @@ -260,7 +269,7 @@ vector2_normalize(mrb_state *mrb, mrb_value self) * @return [Float] length of the vector */ static mrb_value -vector2_length(mrb_state *mrb, mrb_value self) +vector2_length(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, glm::length(get_vector2_value(mrb, self))); } @@ -270,11 +279,12 @@ vector2_length(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector2_distance(mrb_state *mrb, mrb_value self) +vector2_distance(mrb_state* mrb, mrb_value self) { - Moon::Vector2 *other; + Moon::Vector2* other; mrb_get_args(mrb, "d", &other, &vector2_data_type); - return mrb_float_value(mrb, glm::distance(get_vector2_value(mrb, self), *other)); + return mrb_float_value(mrb, + glm::distance(get_vector2_value(mrb, self), *other)); } /* @@ -282,11 +292,12 @@ vector2_distance(mrb_state *mrb, mrb_value self) * @return [Vector2] rotated vector */ static mrb_value -vector2_rotate(mrb_state *mrb, mrb_value self) +vector2_rotate(mrb_state* mrb, mrb_value self) { mrb_float angle; mrb_get_args(mrb, "f", &angle); - return mmrb_vector2_value(mrb, glm::rotate(get_vector2_value(mrb, self), (float)angle)); + return mmrb_vector2_value( + mrb, glm::rotate(get_vector2_value(mrb, self), (float)angle)); } /* Linear interpolation of two quaternions. @@ -294,36 +305,38 @@ vector2_rotate(mrb_state *mrb, mrb_value self) * The interpolation is oriented. * * @param [Vector2] other quaternion - * @param [Float] delta Interpolation factor. The interpolation is defined in the range [0, 1]. + * @param [Float] delta Interpolation factor. The interpolation is defined in + * the range [0, 1]. * @return [Vector2] */ static mrb_value -vector2_lerp(mrb_state *mrb, mrb_value self) +vector2_lerp(mrb_state* mrb, mrb_value self) { - Moon::Vector2 *other; + Moon::Vector2* other; mrb_float delta; mrb_get_args(mrb, "df", &other, &vector2_data_type, &delta); - return mmrb_vector2_value(mrb, glm::lerp(get_vector2_value(mrb, self), *other, (float)delta)); + return mmrb_vector2_value( + mrb, glm::lerp(get_vector2_value(mrb, self), *other, (float)delta)); } static mrb_value -vector2_set(mrb_state *mrb, mrb_value self) +vector2_set(mrb_state* mrb, mrb_value self) { set_vector2(mrb, self, vector2_from_mrb_args(mrb)); return self; } static mrb_value -vector2_to_a(mrb_state *mrb, mrb_value self) +vector2_to_a(mrb_state* mrb, mrb_value self) { - Moon::Vector2 *mvec2 = mmrb_vector2_ptr(mrb, self); + Moon::Vector2* mvec2 = mmrb_vector2_ptr(mrb, self); mrb_value argv[2] = { mrb_float_value(mrb, mvec2->x), mrb_float_value(mrb, mvec2->y) }; return mrb_ary_new_from_values(mrb, 2, argv); } static mrb_value -vector2_s_extract(mrb_state *mrb, mrb_value self) +vector2_s_extract(mrb_state* mrb, mrb_value self) { Moon::Vector2 src_vect = vector2_from_mrb_args(mrb); mrb_value argv[2] = { mrb_float_value(mrb, src_vect.x), @@ -332,13 +345,13 @@ vector2_s_extract(mrb_state *mrb, mrb_value self) } static mrb_value -vector2_s_cast(mrb_state *mrb, mrb_value klass) +vector2_s_cast(mrb_state* mrb, mrb_value klass) { return mmrb_vector2_value(mrb, vector2_from_mrb_args(mrb)); } static mrb_value -vector2_s_circular_rand(mrb_state *mrb, mrb_value klass) +vector2_s_circular_rand(mrb_state* mrb, mrb_value klass) { mrb_float radius; mrb_get_args(mrb, "f", &radius); @@ -346,7 +359,7 @@ vector2_s_circular_rand(mrb_state *mrb, mrb_value klass) } static mrb_value -vector2_s_disk_rand(mrb_state *mrb, mrb_value klass) +vector2_s_disk_rand(mrb_state* mrb, mrb_value klass) { mrb_float radius; mrb_get_args(mrb, "f", &radius); @@ -354,52 +367,66 @@ vector2_s_disk_rand(mrb_state *mrb, mrb_value klass) } MOON_C_API void -mmrb_vector2_init(mrb_state *mrb) +mmrb_vector2_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *vector2_class = mrb_define_class_under(mrb, mod, "Vector2", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* vector2_class = + mrb_define_class_under(mrb, mod, "Vector2", mrb->object_class); MRB_SET_INSTANCE_TT(vector2_class, MRB_TT_DATA); - mrb_define_method(mrb, vector2_class, "initialize", vector2_initialize, MRB_ARGS_OPT(2)); - mrb_define_method(mrb, vector2_class, "initialize_copy", vector2_initialize_copy, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "initialize", vector2_initialize, + MRB_ARGS_OPT(2)); + mrb_define_method(mrb, vector2_class, "initialize_copy", + vector2_initialize_copy, MRB_ARGS_REQ(1)); /* coercion */ - mrb_define_method(mrb, vector2_class, "coerce", vector2_coerce, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "==", vector2_eq, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "coerce", vector2_coerce, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "==", vector2_eq, MRB_ARGS_REQ(1)); /* attribute setters */ - mrb_define_method(mrb, vector2_class, "x", vector2_get_x, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "y", vector2_get_y, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "x=", vector2_set_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "y=", vector2_set_y, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "set", vector2_set, MRB_ARGS_ANY()); + mrb_define_method(mrb, vector2_class, "x", vector2_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "y", vector2_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "x=", vector2_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "y=", vector2_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "set", vector2_set, MRB_ARGS_ANY()); /* arithmetic */ - mrb_define_method(mrb, vector2_class, "-@", vector2_negate, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "+@", vector2_identity, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "+", vector2_add, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "-", vector2_sub, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "*", vector2_mul, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "/", vector2_div, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "dot", vector2_dot, MRB_ARGS_REQ(1)); - /*mrb_define_method(mrb, vector2_class, "cross", vector2_cross, MRB_ARGS_REQ(1));*/ + mrb_define_method(mrb, vector2_class, "-@", vector2_negate, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "+@", vector2_identity, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "+", vector2_add, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "-", vector2_sub, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "*", vector2_mul, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "/", vector2_div, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "dot", vector2_dot, MRB_ARGS_REQ(1)); + /*mrb_define_method(mrb, vector2_class, "cross", vector2_cross, + * MRB_ARGS_REQ(1));*/ /* */ - mrb_define_method(mrb, vector2_class, "normalize", vector2_normalize, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "length", vector2_length, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "distance", vector2_distance, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "rotate", vector2_rotate, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "lerp", vector2_lerp, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, vector2_class, "normalize", vector2_normalize, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "length", vector2_length, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "distance", vector2_distance, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "rotate", vector2_rotate, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "lerp", vector2_lerp, MRB_ARGS_REQ(2)); /* bitwise operators */ - mrb_define_method(mrb, vector2_class, "~@", vector2_not, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "%", vector2_modulo, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "<<", vector2_shl, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, ">>", vector2_shr, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "&", vector2_and, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "|", vector2_or, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "^", vector2_xor, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "~@", vector2_not, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "%", vector2_modulo, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "<<", vector2_shl, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, ">>", vector2_shr, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "&", vector2_and, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "|", vector2_or, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "^", vector2_xor, MRB_ARGS_REQ(1)); /* conversion */ - mrb_define_method(mrb, vector2_class, "to_a", vector2_to_a, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "to_a", vector2_to_a, MRB_ARGS_NONE()); /* cast */ - mrb_define_class_method(mrb, vector2_class, "[]", vector2_s_cast, MRB_ARGS_ANY()); - mrb_define_class_method(mrb, vector2_class, "extract", vector2_s_extract, MRB_ARGS_REQ(1)); + mrb_define_class_method(mrb, vector2_class, "[]", vector2_s_cast, + MRB_ARGS_ANY()); + mrb_define_class_method(mrb, vector2_class, "extract", vector2_s_extract, + MRB_ARGS_REQ(1)); /* gen */ - mrb_define_class_method(mrb, vector2_class, "circular_rand", vector2_s_circular_rand, MRB_ARGS_REQ(1)); - mrb_define_class_method(mrb, vector2_class, "disk_rand", vector2_s_disk_rand, MRB_ARGS_REQ(1)); + mrb_define_class_method(mrb, vector2_class, "circular_rand", + vector2_s_circular_rand, MRB_ARGS_REQ(1)); + mrb_define_class_method(mrb, vector2_class, "disk_rand", vector2_s_disk_rand, + MRB_ARGS_REQ(1)); } diff --git a/modules/system/src/mrb_vector3.cxx b/modules/system/src/mrb_vector3.cxx index 5e38f14..4ac839d 100644 --- a/modules/system/src/mrb_vector3.cxx +++ b/modules/system/src/mrb_vector3.cxx @@ -1,38 +1,43 @@ /* * Moon Vector3, a wrapper around Moon::Vector3 */ -#include -#include -#include -#include -#include #include "moon/mrb/vector1.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector_unroll.hxx" #include "vec_helper.h" +#include +#include +#include +#include +#include -#define m_vector_operator(__op__) \ - return mmrb_vector3_value(mrb, get_vector3_value(mrb, self) __op__ vector3_from_mrb_args(mrb)); +#define m_vector_operator(__op__) \ + return mmrb_vector3_value(mrb, get_vector3_value(mrb, self) \ + __op__ vector3_from_mrb_args(mrb)); -#define m_vector_int_operator(__op__) \ - return mmrb_vector3_value(mrb, Moon::Vector3(glm::ivec3(get_vector3_value(mrb, self)) __op__ glm::ivec3(vector3_from_mrb_args(mrb)))); +#define m_vector_int_operator(__op__) \ + return mmrb_vector3_value( \ + mrb, Moon::Vector3(glm::ivec3(get_vector3_value(mrb, self)) \ + __op__ glm::ivec3(vector3_from_mrb_args(mrb)))); static void -vector3_free(mrb_state *mrb, void *p) +vector3_free(mrb_state* mrb, void* p) { - Moon::Vector3 *vec3 = (Moon::Vector3*)p; + Moon::Vector3* vec3 = (Moon::Vector3*)p; if (vec3) { - delete(vec3); + delete (vec3); } } -MOON_C_API const struct mrb_data_type vector3_data_type = { "Moon::Vector3", vector3_free }; +MOON_C_API const struct mrb_data_type vector3_data_type = { "Moon::Vector3", + vector3_free }; -DEF_VEC_HELPERS(vector3, Moon::Vector3, mmrb_get_vector3_class(mrb), &vector3_data_type); +DEF_VEC_HELPERS(vector3, Moon::Vector3, mmrb_get_vector3_class(mrb), + &vector3_data_type); static Moon::Vector3 -mmrb_vector3_extract_args(mrb_state *mrb, int argc, mrb_value *vals) +mmrb_vector3_extract_args(mrb_state* mrb, int argc, mrb_value* vals) { mrb_float result[3]; mmrb_vector_unroll(mrb, argc, vals, 3, result); @@ -40,22 +45,22 @@ mmrb_vector3_extract_args(mrb_state *mrb, int argc, mrb_value *vals) } static Moon::Vector3 -vector3_from_mrb_args(mrb_state *mrb) +vector3_from_mrb_args(mrb_state* mrb) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); return mmrb_vector3_extract_args(mrb, len, vals); } MOON_C_API Moon::Vector3 -mmrb_to_vector3(mrb_state *mrb, mrb_value obj) +mmrb_to_vector3(mrb_state* mrb, mrb_value obj) { return mmrb_vector3_extract_args(mrb, 1, &obj); } MOON_C_API mrb_value -mmrb_vector3_value(mrb_state *mrb, Moon::Vector3 vec) +mmrb_vector3_value(mrb_state* mrb, Moon::Vector3 vec) { return set_vector3(mrb, new_vector3(mrb), vec); } @@ -69,7 +74,7 @@ mmrb_vector3_value(mrb_state *mrb, Moon::Vector3 vec) * @return [self] */ static mrb_value -vector3_initialize(mrb_state *mrb, mrb_value self) +vector3_initialize(mrb_state* mrb, mrb_value self) { mrb_float x = 0.0; mrb_float y = 0.0; @@ -81,10 +86,11 @@ vector3_initialize(mrb_state *mrb, mrb_value self) }; static mrb_value -vector3_initialize_copy(mrb_state *mrb, mrb_value self) +vector3_initialize_copy(mrb_state* mrb, mrb_value self) { cleanup_vector3(mrb, self); - mrb_data_init(self, new Moon::Vector3(vector3_from_mrb_args(mrb)), &vector3_data_type); + mrb_data_init(self, new Moon::Vector3(vector3_from_mrb_args(mrb)), + &vector3_data_type); return self; } @@ -96,7 +102,7 @@ vector3_initialize_copy(mrb_state *mrb, mrb_value self) * @api private */ static mrb_value -vector3_coerce(mrb_state *mrb, mrb_value self) +vector3_coerce(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); @@ -111,36 +117,37 @@ vector3_coerce(mrb_state *mrb, mrb_value self) * @return [Boolean] true other and self are equal, false otherwise */ static mrb_value -vector3_eq(mrb_state *mrb, mrb_value self) +vector3_eq(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); if (mrb_obj_is_kind_of(mrb, other, mmrb_get_vector3_class(mrb))) { - return mrb_bool_value((*mmrb_vector3_ptr(mrb, self)) == (*mmrb_vector3_ptr(mrb, other))); + return mrb_bool_value((*mmrb_vector3_ptr(mrb, self)) == + (*mmrb_vector3_ptr(mrb, other))); } return mrb_bool_value(false); } static mrb_value -vector3_get_x(mrb_state *mrb, mrb_value self) +vector3_get_x(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector3_ptr(mrb, self)->x); } static mrb_value -vector3_get_y(mrb_state *mrb, mrb_value self) +vector3_get_y(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector3_ptr(mrb, self)->y); } static mrb_value -vector3_get_z(mrb_state *mrb, mrb_value self) +vector3_get_z(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector3_ptr(mrb, self)->z); } static mrb_value -vector3_set_x(mrb_state *mrb, mrb_value self) +vector3_set_x(mrb_state* mrb, mrb_value self) { mrb_float x; mrb_get_args(mrb, "f", &x); @@ -149,7 +156,7 @@ vector3_set_x(mrb_state *mrb, mrb_value self) } static mrb_value -vector3_set_y(mrb_state *mrb, mrb_value self) +vector3_set_y(mrb_state* mrb, mrb_value self) { mrb_float y; mrb_get_args(mrb, "f", &y); @@ -158,7 +165,7 @@ vector3_set_y(mrb_state *mrb, mrb_value self) } static mrb_value -vector3_set_z(mrb_state *mrb, mrb_value self) +vector3_set_z(mrb_state* mrb, mrb_value self) { mrb_float z; mrb_get_args(mrb, "f", &z); @@ -172,7 +179,7 @@ vector3_set_z(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_negate(mrb_state *mrb, mrb_value self) +vector3_negate(mrb_state* mrb, mrb_value self) { return mmrb_vector3_value(mrb, -get_vector3_value(mrb, self)); } @@ -183,7 +190,7 @@ vector3_negate(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_identity(mrb_state *mrb, mrb_value self) +vector3_identity(mrb_state* mrb, mrb_value self) { return mrb_obj_dup(mrb, self); } @@ -192,7 +199,7 @@ vector3_identity(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_normalize(mrb_state *mrb, mrb_value self) +vector3_normalize(mrb_state* mrb, mrb_value self) { return mmrb_vector3_value(mrb, glm::normalize(get_vector3_value(mrb, self))); } @@ -201,32 +208,32 @@ vector3_normalize(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector3_length(mrb_state *mrb, mrb_value self) +vector3_length(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, glm::length(get_vector3_value(mrb, self))); } // @return [Vector3] static mrb_value -vector3_add(mrb_state *mrb, mrb_value self) +vector3_add(mrb_state* mrb, mrb_value self) { m_vector_operator(+); } static mrb_value -vector3_sub(mrb_state *mrb, mrb_value self) +vector3_sub(mrb_state* mrb, mrb_value self) { m_vector_operator(-); } static mrb_value -vector3_mul(mrb_state *mrb, mrb_value self) +vector3_mul(mrb_state* mrb, mrb_value self) { m_vector_operator(*); } static mrb_value -vector3_div(mrb_state *mrb, mrb_value self) +vector3_div(mrb_state* mrb, mrb_value self) { m_vector_operator(/); } @@ -237,45 +244,46 @@ vector3_div(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_not(mrb_state *mrb, mrb_value self) +vector3_not(mrb_state* mrb, mrb_value self) { - return mmrb_vector3_value(mrb, Moon::Vector3(~(glm::ivec3(*mmrb_vector3_ptr(mrb, self))))); + return mmrb_vector3_value( + mrb, Moon::Vector3(~(glm::ivec3(*mmrb_vector3_ptr(mrb, self))))); } static mrb_value -vector3_modulo(mrb_state *mrb, mrb_value self) +vector3_modulo(mrb_state* mrb, mrb_value self) { m_vector_int_operator(%); } static mrb_value -vector3_shl(mrb_state *mrb, mrb_value self) +vector3_shl(mrb_state* mrb, mrb_value self) { m_vector_int_operator(<<); } static mrb_value -vector3_shr(mrb_state *mrb, mrb_value self) +vector3_shr(mrb_state* mrb, mrb_value self) { m_vector_int_operator(>>); } static mrb_value -vector3_and(mrb_state *mrb, mrb_value self) +vector3_and(mrb_state* mrb, mrb_value self) { m_vector_int_operator(&); } static mrb_value -vector3_or(mrb_state *mrb, mrb_value self) +vector3_or(mrb_state* mrb, mrb_value self) { m_vector_int_operator(|); } static mrb_value -vector3_xor(mrb_state *mrb, mrb_value self) +vector3_xor(mrb_state* mrb, mrb_value self) { - m_vector_int_operator(^); + m_vector_int_operator (^); } /* Returns the dot product of self and other, i.e., result = self * other. @@ -283,9 +291,9 @@ vector3_xor(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector3_dot(mrb_state *mrb, mrb_value self) +vector3_dot(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *other; + Moon::Vector3* other; mrb_get_args(mrb, "d", &other, &vector3_data_type); return mrb_float_value(mrb, glm::dot(get_vector3_value(mrb, self), *other)); } @@ -295,9 +303,9 @@ vector3_dot(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_cross(mrb_state *mrb, mrb_value self) +vector3_cross(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *other; + Moon::Vector3* other; mrb_value dest_vec; mrb_get_args(mrb, "d", &other, &vector3_data_type); dest_vec = mrb_obj_dup(mrb, self); @@ -310,11 +318,12 @@ vector3_cross(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector3_distance(mrb_state *mrb, mrb_value self) +vector3_distance(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *other; + Moon::Vector3* other; mrb_get_args(mrb, "d", &other, &vector3_data_type); - return mrb_float_value(mrb, glm::distance(get_vector3_value(mrb, self), *other)); + return mrb_float_value(mrb, + glm::distance(get_vector3_value(mrb, self), *other)); } /* * @param [Vector3] other @@ -322,12 +331,13 @@ vector3_distance(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_rotate(mrb_state *mrb, mrb_value self) +vector3_rotate(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *other; + Moon::Vector3* other; mrb_float angle; mrb_get_args(mrb, "df", &other, &vector3_data_type, &angle); - return mmrb_vector3_value(mrb, glm::rotate(*mmrb_vector3_ptr(mrb, self), (float)angle, *other)); + return mmrb_vector3_value( + mrb, glm::rotate(*mmrb_vector3_ptr(mrb, self), (float)angle, *other)); } /* Rotate the vector around the x axis. @@ -335,11 +345,12 @@ vector3_rotate(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_rotate_x(mrb_state *mrb, mrb_value self) +vector3_rotate_x(mrb_state* mrb, mrb_value self) { mrb_float angle; mrb_get_args(mrb, "f", &angle); - return mmrb_vector3_value(mrb, glm::rotateX(*mmrb_vector3_ptr(mrb, self), (float)angle)); + return mmrb_vector3_value( + mrb, glm::rotateX(*mmrb_vector3_ptr(mrb, self), (float)angle)); } /* Rotate the vector around the y axis. @@ -347,11 +358,12 @@ vector3_rotate_x(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_rotate_y(mrb_state *mrb, mrb_value self) +vector3_rotate_y(mrb_state* mrb, mrb_value self) { mrb_float angle; mrb_get_args(mrb, "f", &angle); - return mmrb_vector3_value(mrb, glm::rotateY(*mmrb_vector3_ptr(mrb, self), (float)angle)); + return mmrb_vector3_value( + mrb, glm::rotateY(*mmrb_vector3_ptr(mrb, self), (float)angle)); } /* Rotate the vector around the z axis. @@ -359,11 +371,12 @@ vector3_rotate_y(mrb_state *mrb, mrb_value self) * @return [Vector3] */ static mrb_value -vector3_rotate_z(mrb_state *mrb, mrb_value self) +vector3_rotate_z(mrb_state* mrb, mrb_value self) { mrb_float angle; mrb_get_args(mrb, "f", &angle); - return mmrb_vector3_value(mrb, glm::rotateZ(*mmrb_vector3_ptr(mrb, self), (float)angle)); + return mmrb_vector3_value( + mrb, glm::rotateZ(*mmrb_vector3_ptr(mrb, self), (float)angle)); } /* Linear interpolation of two quaternions. @@ -371,41 +384,46 @@ vector3_rotate_z(mrb_state *mrb, mrb_value self) * The interpolation is oriented. * * @param [Vector3] other quaternion - * @param [Float] delta Interpolation factor. The interpolation is defined in the range [0, 1]. + * @param [Float] delta Interpolation factor. The interpolation is defined in + * the range [0, 1]. * @return [Vector3] */ static mrb_value -vector3_lerp(mrb_state *mrb, mrb_value self) +vector3_lerp(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *other; + Moon::Vector3* other; mrb_float delta; mrb_get_args(mrb, "df", &other, &vector3_data_type, &delta); - return mmrb_vector3_value(mrb, glm::lerp(*mmrb_vector3_ptr(mrb, self), *other, (float)delta)); + return mmrb_vector3_value( + mrb, glm::lerp(*mmrb_vector3_ptr(mrb, self), *other, (float)delta)); } /* Spherical linear interpolation of two quaternions. * * Returns the slurp interpolation between two quaternions. * - * The interpolation always take the short path and the rotation is performed at constant speed. + * The interpolation always take the short path and the rotation is performed at + * constant speed. * * @param [Vector3] other quaternion - * @param [Float] delta Interpolation factor. The interpolation is defined beyond the range [0, 1]. + * @param [Float] delta Interpolation factor. The interpolation is defined + * beyond the range [0, 1]. * @return [Vector3] */ static mrb_value -vector3_slerp(mrb_state *mrb, mrb_value self) +vector3_slerp(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *other; + Moon::Vector3* other; mrb_float delta; mrb_get_args(mrb, "df", &other, &vector3_data_type, &delta); - return mmrb_vector3_value(mrb, glm::slerp(*mmrb_vector3_ptr(mrb, self), *other, (float)delta)); + return mmrb_vector3_value( + mrb, glm::slerp(*mmrb_vector3_ptr(mrb, self), *other, (float)delta)); } static mrb_value -vector3_set(mrb_state *mrb, mrb_value self) +vector3_set(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *v3; + Moon::Vector3* v3; v3 = mmrb_vector3_ptr(mrb, self); *v3 = vector3_from_mrb_args(mrb); return self; @@ -413,9 +431,9 @@ vector3_set(mrb_state *mrb, mrb_value self) // @return [Array] static mrb_value -vector3_to_a(mrb_state *mrb, mrb_value self) +vector3_to_a(mrb_state* mrb, mrb_value self) { - Moon::Vector3 *mvec3 = mmrb_vector3_ptr(mrb, self); + Moon::Vector3* mvec3 = mmrb_vector3_ptr(mrb, self); mrb_value argv[3] = { mrb_float_value(mrb, mvec3->x), mrb_float_value(mrb, mvec3->y), mrb_float_value(mrb, mvec3->z) }; @@ -424,7 +442,7 @@ vector3_to_a(mrb_state *mrb, mrb_value self) // @return [Array] static mrb_value -vector3_s_extract(mrb_state *mrb, mrb_value klass) +vector3_s_extract(mrb_state* mrb, mrb_value klass) { Moon::Vector3 src_vect = vector3_from_mrb_args(mrb); mrb_value argv[3] = { mrb_float_value(mrb, src_vect.x), @@ -434,69 +452,91 @@ vector3_s_extract(mrb_state *mrb, mrb_value klass) } static mrb_value -vector3_s_cast(mrb_state *mrb, mrb_value klass) +vector3_s_cast(mrb_state* mrb, mrb_value klass) { return mmrb_vector3_value(mrb, vector3_from_mrb_args(mrb)); } MOON_C_API void -mmrb_vector3_init(mrb_state *mrb) +mmrb_vector3_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *vector3_class = mrb_define_class_under(mrb, mod, "Vector3", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* vector3_class = + mrb_define_class_under(mrb, mod, "Vector3", mrb->object_class); MRB_SET_INSTANCE_TT(vector3_class, MRB_TT_DATA); - mrb_define_method(mrb, vector3_class, "initialize", vector3_initialize, MRB_ARGS_OPT(3)); - mrb_define_method(mrb, vector3_class, "initialize_copy", vector3_initialize_copy, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "initialize", vector3_initialize, + MRB_ARGS_OPT(3)); + mrb_define_method(mrb, vector3_class, "initialize_copy", + vector3_initialize_copy, MRB_ARGS_REQ(1)); /* coercion */ - mrb_define_method(mrb, vector3_class, "coerce", vector3_coerce, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "==", vector3_eq, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "coerce", vector3_coerce, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "==", vector3_eq, MRB_ARGS_REQ(1)); /* attribute setters */ - mrb_define_method(mrb, vector3_class, "x", vector3_get_x, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "y", vector3_get_y, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "z", vector3_get_z, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "x=", vector3_set_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "y=", vector3_set_y, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "z=", vector3_set_z, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "set", vector3_set, MRB_ARGS_ANY()); + mrb_define_method(mrb, vector3_class, "x", vector3_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "y", vector3_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "z", vector3_get_z, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "x=", vector3_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "y=", vector3_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "z=", vector3_set_z, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "set", vector3_set, MRB_ARGS_ANY()); /* arithmetic */ - mrb_define_method(mrb, vector3_class, "-@", vector3_negate, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "+@", vector3_identity, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "+", vector3_add, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "-", vector3_sub, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "*", vector3_mul, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "/", vector3_div, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "dot", vector3_dot, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "cross", vector3_cross, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "-@", vector3_negate, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "+@", vector3_identity, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "+", vector3_add, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "-", vector3_sub, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "*", vector3_mul, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "/", vector3_div, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "dot", vector3_dot, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "cross", vector3_cross, + MRB_ARGS_REQ(1)); /* */ - mrb_define_method(mrb, vector3_class, "normalize", vector3_normalize, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "length", vector3_length, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "distance", vector3_distance, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "rotate", vector3_rotate, MRB_ARGS_REQ(2)); - mrb_define_method(mrb, vector3_class, "rotate_x", vector3_rotate_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "rotate_y", vector3_rotate_y, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "rotate_z", vector3_rotate_z, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "lerp", vector3_lerp, MRB_ARGS_REQ(2)); - mrb_define_method(mrb, vector3_class, "slerp", vector3_slerp, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, vector3_class, "normalize", vector3_normalize, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "length", vector3_length, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "distance", vector3_distance, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "rotate", vector3_rotate, + MRB_ARGS_REQ(2)); + mrb_define_method(mrb, vector3_class, "rotate_x", vector3_rotate_x, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "rotate_y", vector3_rotate_y, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "rotate_z", vector3_rotate_z, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "lerp", vector3_lerp, MRB_ARGS_REQ(2)); + mrb_define_method(mrb, vector3_class, "slerp", vector3_slerp, + MRB_ARGS_REQ(2)); /* bitwise operators */ - mrb_define_method(mrb, vector3_class, "~@", vector3_not, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector3_class, "%", vector3_modulo, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "<<", vector3_shl, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, ">>", vector3_shr, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "&", vector3_and, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "|", vector3_or, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector3_class, "^", vector3_xor, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "~@", vector3_not, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "%", vector3_modulo, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "<<", vector3_shl, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, ">>", vector3_shr, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "&", vector3_and, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "|", vector3_or, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "^", vector3_xor, MRB_ARGS_REQ(1)); /* conversion */ - mrb_define_method(mrb, vector3_class, "to_a", vector3_to_a, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "to_a", vector3_to_a, MRB_ARGS_NONE()); /* cast */ - mrb_define_class_method(mrb, vector3_class, "[]", vector3_s_cast, MRB_ARGS_ANY()); - mrb_define_class_method(mrb, vector3_class, "extract", vector3_s_extract, MRB_ARGS_REQ(1)); - - mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "r"), mrb_intern_cstr(mrb, "x")); - mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "g"), mrb_intern_cstr(mrb, "y")); - mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "b"), mrb_intern_cstr(mrb, "z")); - - mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "r="), mrb_intern_cstr(mrb, "x=")); - mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "g="), mrb_intern_cstr(mrb, "y=")); - mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "b="), mrb_intern_cstr(mrb, "z=")); + mrb_define_class_method(mrb, vector3_class, "[]", vector3_s_cast, + MRB_ARGS_ANY()); + mrb_define_class_method(mrb, vector3_class, "extract", vector3_s_extract, + MRB_ARGS_REQ(1)); + + mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "r"), + mrb_intern_cstr(mrb, "x")); + mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "g"), + mrb_intern_cstr(mrb, "y")); + mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "b"), + mrb_intern_cstr(mrb, "z")); + + mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "r="), + mrb_intern_cstr(mrb, "x=")); + mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "g="), + mrb_intern_cstr(mrb, "y=")); + mrb_alias_method(mrb, vector3_class, mrb_intern_cstr(mrb, "b="), + mrb_intern_cstr(mrb, "z=")); } diff --git a/modules/system/src/mrb_vector4.cxx b/modules/system/src/mrb_vector4.cxx index c77b7f2..7fca96b 100644 --- a/modules/system/src/mrb_vector4.cxx +++ b/modules/system/src/mrb_vector4.cxx @@ -1,39 +1,44 @@ /* * Moon Vector4, a wrapper around Moon::Vector4 */ -#include -#include -#include -#include -#include #include "moon/mrb/vector1.hxx" #include "moon/mrb/vector2.hxx" #include "moon/mrb/vector3.hxx" #include "moon/mrb/vector4.hxx" #include "moon/mrb/vector_unroll.hxx" #include "vec_helper.h" +#include +#include +#include +#include +#include -#define m_vector_operator(__op__) \ - return mmrb_vector4_value(mrb, get_vector4_value(mrb, self) __op__ vector4_from_mrb_args(mrb)); +#define m_vector_operator(__op__) \ + return mmrb_vector4_value(mrb, get_vector4_value(mrb, self) \ + __op__ vector4_from_mrb_args(mrb)); -#define m_vector_int_operator(__op__) \ - return mmrb_vector4_value(mrb, Moon::Vector4(glm::ivec4(get_vector4_value(mrb, self)) __op__ glm::ivec4(vector4_from_mrb_args(mrb)))); +#define m_vector_int_operator(__op__) \ + return mmrb_vector4_value( \ + mrb, Moon::Vector4(glm::ivec4(get_vector4_value(mrb, self)) \ + __op__ glm::ivec4(vector4_from_mrb_args(mrb)))); static void -vector4_free(mrb_state *mrb, void *p) +vector4_free(mrb_state* mrb, void* p) { - Moon::Vector4 *vec4 = (Moon::Vector4*)p; + Moon::Vector4* vec4 = (Moon::Vector4*)p; if (vec4) { - delete(vec4); + delete (vec4); } } -MOON_C_API const struct mrb_data_type vector4_data_type = { "Moon::Vector4", vector4_free }; +MOON_C_API const struct mrb_data_type vector4_data_type = { "Moon::Vector4", + vector4_free }; -DEF_VEC_HELPERS(vector4, Moon::Vector4, mmrb_get_vector4_class(mrb), &vector4_data_type); +DEF_VEC_HELPERS(vector4, Moon::Vector4, mmrb_get_vector4_class(mrb), + &vector4_data_type); static Moon::Vector4 -mmrb_vector4_extract_args(mrb_state *mrb, int argc, mrb_value *vals) +mmrb_vector4_extract_args(mrb_state* mrb, int argc, mrb_value* vals) { mrb_float result[4]; mmrb_vector_unroll(mrb, argc, vals, 4, result); @@ -41,22 +46,22 @@ mmrb_vector4_extract_args(mrb_state *mrb, int argc, mrb_value *vals) } static Moon::Vector4 -vector4_from_mrb_args(mrb_state *mrb) +vector4_from_mrb_args(mrb_state* mrb) { - mrb_value *vals; + mrb_value* vals; int len; mrb_get_args(mrb, "*", &vals, &len); return mmrb_vector4_extract_args(mrb, len, vals); } MOON_C_API Moon::Vector4 -mmrb_to_vector4(mrb_state *mrb, mrb_value obj) +mmrb_to_vector4(mrb_state* mrb, mrb_value obj) { return mmrb_vector4_extract_args(mrb, 1, &obj); } MOON_C_API mrb_value -mmrb_vector4_value(mrb_state *mrb, Moon::Vector4 vec) +mmrb_vector4_value(mrb_state* mrb, Moon::Vector4 vec) { return set_vector4(mrb, new_vector4(mrb), vec); } @@ -71,7 +76,7 @@ mmrb_vector4_value(mrb_state *mrb, Moon::Vector4 vec) * @param [Numeric] w */ static mrb_value -vector4_initialize(mrb_state *mrb, mrb_value self) +vector4_initialize(mrb_state* mrb, mrb_value self) { mrb_float x = 0.0; mrb_float y = 0.0; @@ -84,10 +89,11 @@ vector4_initialize(mrb_state *mrb, mrb_value self) } static mrb_value -vector4_initialize_copy(mrb_state *mrb, mrb_value self) +vector4_initialize_copy(mrb_state* mrb, mrb_value self) { cleanup_vector4(mrb, self); - mrb_data_init(self, new Moon::Vector4(vector4_from_mrb_args(mrb)), &vector4_data_type); + mrb_data_init(self, new Moon::Vector4(vector4_from_mrb_args(mrb)), + &vector4_data_type); return self; } @@ -99,7 +105,7 @@ vector4_initialize_copy(mrb_state *mrb, mrb_value self) * @api private */ static mrb_value -vector4_coerce(mrb_state *mrb, mrb_value self) +vector4_coerce(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); @@ -114,42 +120,43 @@ vector4_coerce(mrb_state *mrb, mrb_value self) * @return [Boolean] true other and self are equal, false otherwise */ static mrb_value -vector4_eq(mrb_state *mrb, mrb_value self) +vector4_eq(mrb_state* mrb, mrb_value self) { mrb_value other; mrb_get_args(mrb, "o", &other); if (mrb_obj_is_kind_of(mrb, other, mmrb_get_vector4_class(mrb))) { - return mrb_bool_value((*mmrb_vector4_ptr(mrb, self)) == (*mmrb_vector4_ptr(mrb, other))); + return mrb_bool_value((*mmrb_vector4_ptr(mrb, self)) == + (*mmrb_vector4_ptr(mrb, other))); } return mrb_bool_value(false); } static mrb_value -vector4_get_x(mrb_state *mrb, mrb_value self) +vector4_get_x(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector4_ptr(mrb, self)->x); } static mrb_value -vector4_get_y(mrb_state *mrb, mrb_value self) +vector4_get_y(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector4_ptr(mrb, self)->y); } static mrb_value -vector4_get_z(mrb_state *mrb, mrb_value self) +vector4_get_z(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector4_ptr(mrb, self)->z); } static mrb_value -vector4_get_w(mrb_state *mrb, mrb_value self) +vector4_get_w(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, mmrb_vector4_ptr(mrb, self)->w); } static mrb_value -vector4_set_x(mrb_state *mrb, mrb_value self) +vector4_set_x(mrb_state* mrb, mrb_value self) { mrb_float x; mrb_get_args(mrb, "f", &x); @@ -158,7 +165,7 @@ vector4_set_x(mrb_state *mrb, mrb_value self) } static mrb_value -vector4_set_y(mrb_state *mrb, mrb_value self) +vector4_set_y(mrb_state* mrb, mrb_value self) { mrb_float y; mrb_get_args(mrb, "f", &y); @@ -167,7 +174,7 @@ vector4_set_y(mrb_state *mrb, mrb_value self) } static mrb_value -vector4_set_z(mrb_state *mrb, mrb_value self) +vector4_set_z(mrb_state* mrb, mrb_value self) { mrb_float z; mrb_get_args(mrb, "f", &z); @@ -176,7 +183,7 @@ vector4_set_z(mrb_state *mrb, mrb_value self) } static mrb_value -vector4_set_w(mrb_state *mrb, mrb_value self) +vector4_set_w(mrb_state* mrb, mrb_value self) { mrb_float w; mrb_get_args(mrb, "f", &w); @@ -190,7 +197,7 @@ vector4_set_w(mrb_state *mrb, mrb_value self) * @return [Vector4] */ static mrb_value -vector4_negate(mrb_state *mrb, mrb_value self) +vector4_negate(mrb_state* mrb, mrb_value self) { return mmrb_vector4_value(mrb, -get_vector4_value(mrb, self)); } @@ -201,7 +208,7 @@ vector4_negate(mrb_state *mrb, mrb_value self) * @return [Vector4] */ static mrb_value -vector4_identity(mrb_state *mrb, mrb_value self) +vector4_identity(mrb_state* mrb, mrb_value self) { return mrb_obj_dup(mrb, self); } @@ -210,7 +217,7 @@ vector4_identity(mrb_state *mrb, mrb_value self) * @return [Vector4] */ static mrb_value -vector4_normalize(mrb_state *mrb, mrb_value self) +vector4_normalize(mrb_state* mrb, mrb_value self) { return mmrb_vector4_value(mrb, glm::normalize(get_vector4_value(mrb, self))); } @@ -219,31 +226,31 @@ vector4_normalize(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector4_length(mrb_state *mrb, mrb_value self) +vector4_length(mrb_state* mrb, mrb_value self) { return mrb_float_value(mrb, glm::length(get_vector4_value(mrb, self))); } static mrb_value -vector4_add(mrb_state *mrb, mrb_value self) +vector4_add(mrb_state* mrb, mrb_value self) { m_vector_operator(+); } static mrb_value -vector4_sub(mrb_state *mrb, mrb_value self) +vector4_sub(mrb_state* mrb, mrb_value self) { m_vector_operator(-); } static mrb_value -vector4_mul(mrb_state *mrb, mrb_value self) +vector4_mul(mrb_state* mrb, mrb_value self) { m_vector_operator(*); } static mrb_value -vector4_div(mrb_state *mrb, mrb_value self) +vector4_div(mrb_state* mrb, mrb_value self) { m_vector_operator(/); } @@ -254,51 +261,53 @@ vector4_div(mrb_state *mrb, mrb_value self) * @return [Vector4] */ static mrb_value -vector4_not(mrb_state *mrb, mrb_value self) +vector4_not(mrb_state* mrb, mrb_value self) { - return mmrb_vector4_value(mrb, Moon::Vector4(~(glm::ivec4(*mmrb_vector4_ptr(mrb, self))))); + return mmrb_vector4_value( + mrb, Moon::Vector4(~(glm::ivec4(*mmrb_vector4_ptr(mrb, self))))); } static mrb_value -vector4_modulo(mrb_state *mrb, mrb_value self) +vector4_modulo(mrb_state* mrb, mrb_value self) { m_vector_int_operator(%); } static mrb_value -vector4_shl(mrb_state *mrb, mrb_value self) +vector4_shl(mrb_state* mrb, mrb_value self) { m_vector_int_operator(<<); } static mrb_value -vector4_shr(mrb_state *mrb, mrb_value self) +vector4_shr(mrb_state* mrb, mrb_value self) { m_vector_int_operator(>>); } static mrb_value -vector4_and(mrb_state *mrb, mrb_value self) +vector4_and(mrb_state* mrb, mrb_value self) { m_vector_int_operator(&); } static mrb_value -vector4_or(mrb_state *mrb, mrb_value self) +vector4_or(mrb_state* mrb, mrb_value self) { m_vector_int_operator(|); } static mrb_value -vector4_xor(mrb_state *mrb, mrb_value self) +vector4_xor(mrb_state* mrb, mrb_value self) { - m_vector_int_operator(^); + m_vector_int_operator (^); } static mrb_value -vector4_dot(mrb_state *mrb, mrb_value self) +vector4_dot(mrb_state* mrb, mrb_value self) { - return mrb_float_value(mrb, glm::dot(get_vector4_value(mrb, self), vector4_from_mrb_args(mrb))); + return mrb_float_value( + mrb, glm::dot(get_vector4_value(mrb, self), vector4_from_mrb_args(mrb))); } /* Returns the distance betwwen self and other, i.e., length(p0 - p1). @@ -306,15 +315,16 @@ vector4_dot(mrb_state *mrb, mrb_value self) * @return [Float] */ static mrb_value -vector4_distance(mrb_state *mrb, mrb_value self) +vector4_distance(mrb_state* mrb, mrb_value self) { - Moon::Vector4 *other; + Moon::Vector4* other; mrb_get_args(mrb, "d", &other, &vector4_data_type); - return mrb_float_value(mrb, glm::distance(get_vector4_value(mrb, self), *other)); + return mrb_float_value(mrb, + glm::distance(get_vector4_value(mrb, self), *other)); } static mrb_value -vector4_set(mrb_state *mrb, mrb_value self) +vector4_set(mrb_state* mrb, mrb_value self) { return set_vector4(mrb, self, vector4_from_mrb_args(mrb)); } @@ -325,7 +335,7 @@ vector4_set(mrb_state *mrb, mrb_value self) * @return [Array] */ static mrb_value -vector4_to_a(mrb_state *mrb, mrb_value self) +vector4_to_a(mrb_state* mrb, mrb_value self) { Moon::Vector4* mvec4 = mmrb_vector4_ptr(mrb, self); mrb_value argv[4] = { mrb_float_value(mrb, mvec4->x), @@ -336,7 +346,7 @@ vector4_to_a(mrb_state *mrb, mrb_value self) } static mrb_value -vector4_s_extract(mrb_state *mrb, mrb_value self) +vector4_s_extract(mrb_state* mrb, mrb_value self) { Moon::Vector4 v4a = vector4_from_mrb_args(mrb); mrb_value argv[4] = { mrb_float_value(mrb, v4a.x), @@ -347,66 +357,85 @@ vector4_s_extract(mrb_state *mrb, mrb_value self) } static mrb_value -vector4_s_cast(mrb_state *mrb, mrb_value klass) +vector4_s_cast(mrb_state* mrb, mrb_value klass) { return set_vector4(mrb, new_vector4(mrb), vector4_from_mrb_args(mrb)); } MOON_C_API void -mmrb_vector4_init(mrb_state *mrb) +mmrb_vector4_init(mrb_state* mrb) { - struct RClass *mod = mrb_define_module(mrb, "Moon"); - struct RClass *vector4_class = mrb_define_class_under(mrb, mod, "Vector4", mrb->object_class); + struct RClass* mod = mrb_define_module(mrb, "Moon"); + struct RClass* vector4_class = + mrb_define_class_under(mrb, mod, "Vector4", mrb->object_class); MRB_SET_INSTANCE_TT(vector4_class, MRB_TT_DATA); - mrb_define_method(mrb, vector4_class, "initialize", vector4_initialize, MRB_ARGS_OPT(4)); - mrb_define_method(mrb, vector4_class, "initialize_copy", vector4_initialize_copy, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "initialize", vector4_initialize, + MRB_ARGS_OPT(4)); + mrb_define_method(mrb, vector4_class, "initialize_copy", + vector4_initialize_copy, MRB_ARGS_REQ(1)); /* coercion */ - mrb_define_method(mrb, vector4_class, "coerce", vector4_coerce, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "==", vector4_eq, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "coerce", vector4_coerce, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "==", vector4_eq, MRB_ARGS_REQ(1)); /* attribute setters */ - mrb_define_method(mrb, vector4_class, "x", vector4_get_x, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "y", vector4_get_y, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "z", vector4_get_z, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "w", vector4_get_w, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "x=", vector4_set_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "y=", vector4_set_y, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "z=", vector4_set_z, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "w=", vector4_set_w, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "set", vector4_set, MRB_ARGS_ANY()); + mrb_define_method(mrb, vector4_class, "x", vector4_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "y", vector4_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "z", vector4_get_z, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "w", vector4_get_w, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "x=", vector4_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "y=", vector4_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "z=", vector4_set_z, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "w=", vector4_set_w, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "set", vector4_set, MRB_ARGS_ANY()); /* arithmetic */ - mrb_define_method(mrb, vector4_class, "-@", vector4_negate, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "+@", vector4_identity, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "normalize", vector4_normalize, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "length", vector4_length, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "+", vector4_add, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "-", vector4_sub, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "*", vector4_mul, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "/", vector4_div, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "dot", vector4_dot, MRB_ARGS_REQ(1)); - //mrb_define_method(mrb, vector4_class, "cross", vector4_cross, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "distance", vector4_distance, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "-@", vector4_negate, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "+@", vector4_identity, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "normalize", vector4_normalize, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "length", vector4_length, + MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "+", vector4_add, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "-", vector4_sub, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "*", vector4_mul, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "/", vector4_div, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "dot", vector4_dot, MRB_ARGS_REQ(1)); + // mrb_define_method(mrb, vector4_class, "cross", vector4_cross, + // MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "distance", vector4_distance, + MRB_ARGS_REQ(1)); /* bitwise operators */ - mrb_define_method(mrb, vector4_class, "~@", vector4_not, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector4_class, "%", vector4_modulo, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "<<", vector4_shl, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, ">>", vector4_shr, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "&", vector4_and, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "|", vector4_or, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector4_class, "^", vector4_xor, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "~@", vector4_not, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "%", vector4_modulo, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "<<", vector4_shl, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, ">>", vector4_shr, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "&", vector4_and, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "|", vector4_or, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "^", vector4_xor, MRB_ARGS_REQ(1)); /* conversion */ - mrb_define_method(mrb, vector4_class, "to_a", vector4_to_a, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "to_a", vector4_to_a, MRB_ARGS_NONE()); /* cast */ - mrb_define_class_method(mrb, vector4_class, "[]", vector4_s_cast, MRB_ARGS_ANY()); - mrb_define_class_method(mrb, vector4_class, "extract", vector4_s_extract, MRB_ARGS_REQ(1)); - - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "r"), mrb_intern_cstr(mrb, "x")); - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "g"), mrb_intern_cstr(mrb, "y")); - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "b"), mrb_intern_cstr(mrb, "z")); - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "a"), mrb_intern_cstr(mrb, "w")); - - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "r="), mrb_intern_cstr(mrb, "x=")); - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "g="), mrb_intern_cstr(mrb, "y=")); - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "b="), mrb_intern_cstr(mrb, "z=")); - mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "a="), mrb_intern_cstr(mrb, "w=")); + mrb_define_class_method(mrb, vector4_class, "[]", vector4_s_cast, + MRB_ARGS_ANY()); + mrb_define_class_method(mrb, vector4_class, "extract", vector4_s_extract, + MRB_ARGS_REQ(1)); + + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "r"), + mrb_intern_cstr(mrb, "x")); + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "g"), + mrb_intern_cstr(mrb, "y")); + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "b"), + mrb_intern_cstr(mrb, "z")); + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "a"), + mrb_intern_cstr(mrb, "w")); + + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "r="), + mrb_intern_cstr(mrb, "x=")); + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "g="), + mrb_intern_cstr(mrb, "y=")); + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "b="), + mrb_intern_cstr(mrb, "z=")); + mrb_alias_method(mrb, vector4_class, mrb_intern_cstr(mrb, "a="), + mrb_intern_cstr(mrb, "w=")); }