diff options
| -rw-r--r-- | include/mruby-raylib/core.h | 14 | ||||
| -rw-r--r-- | include/mruby-raylib/text.h | 12 | ||||
| -rw-r--r-- | include/mruby-raylib/textures.h | 11 | ||||
| -rw-r--r-- | include/mruby-raylib/types.h | 31 | ||||
| -rw-r--r-- | mrbgem.rake | 4 | ||||
| -rw-r--r-- | mrblib/color.rb | 224 | ||||
| -rw-r--r-- | mrblib/core.rb | 30 | ||||
| -rw-r--r-- | mrblib/raylib.rb | 98 | ||||
| -rw-r--r-- | mrblib/shapes.rb | 2 | ||||
| -rw-r--r-- | mrblib/text.rb | 3 | ||||
| -rw-r--r-- | mrblib/texture.rb | 23 | ||||
| -rw-r--r-- | src/bind.c | 17624 | ||||
| -rw-r--r-- | src/core.c | 168 | ||||
| -rw-r--r-- | src/raylib.c | 1053 | ||||
| -rw-r--r-- | src/text.c | 196 | ||||
| -rw-r--r-- | src/textures.c | 238 | ||||
| -rw-r--r-- | src/types.c | 62 |
17 files changed, 17626 insertions, 2167 deletions
diff --git a/include/mruby-raylib/core.h b/include/mruby-raylib/core.h deleted file mode 100644 index c0e6815..0000000 --- a/include/mruby-raylib/core.h +++ /dev/null @@ -1,14 +0,0 @@ -#ifndef MRUBY_RAYLIB_CORE_H -#define MRUBY_RAYLIB_CORE_H -#include "mruby-raylib/types.h" -#include <mruby/string.h> -#include <mruby/numeric.h> -#include <stdlib.h> -#if defined(PLATFORM_WEB) -#include <emscripten/emscripten.h> -#endif - -void mrb_init_raylib_core(mrb_state*); - -#endif /* end of include guard MRUBY_RAYLIB_CORE_H */ - diff --git a/include/mruby-raylib/text.h b/include/mruby-raylib/text.h deleted file mode 100644 index 19b7a8d..0000000 --- a/include/mruby-raylib/text.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef MRUBY_RAYLIB_TEXT_H -#define MRUBY_RAYLIB_TEXT_H -#include "mruby-raylib/types.h" -#include <raylib.h> -#include <mruby/string.h> -#include <mruby/numeric.h> -#include <stdlib.h> - -void mrb_init_raylib_text(mrb_state*); - -#endif /* end of include guard TEXT_H */ - diff --git a/include/mruby-raylib/textures.h b/include/mruby-raylib/textures.h deleted file mode 100644 index 2833117..0000000 --- a/include/mruby-raylib/textures.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef MRUBY_RAYLIB_TEXTURES_H -#define MRUBY_RAYLIB_TEXTURES_H -#include "mruby-raylib/types.h" -#include <raylib.h> -#include <mruby/string.h> -#include <mruby/numeric.h> -#include <stdlib.h> - -void mrb_init_raylib_textures(mrb_state*); - -#endif diff --git a/include/mruby-raylib/types.h b/include/mruby-raylib/types.h deleted file mode 100644 index 3052ec5..0000000 --- a/include/mruby-raylib/types.h +++ /dev/null @@ -1,31 +0,0 @@ -#ifndef MRUBY_RAYLIB_TYPES_H -#define MRUBY_RAYLIB_TYPES_H -#include <mruby.h> -#include <mruby/data.h> - -#define PREWRAPSTRUCT(var_name, type, target) var_name = (type *)DATA_PTR(target) - -#define WRAPSTRUCT(type, mrb_type, target, var_name) \ - PREWRAPSTRUCT(var_name, type, target);\ - if(var_name) { mrb_free(mrb, var_name); }\ - mrb_data_init(target, NULL, &mrb_type);\ - var_name = (type *)mrb_malloc(mrb, sizeof(type));\ - -#define UNWRAPSTRUCT(type, mrb_type, target, var_name) var_name = DATA_GET_PTR(mrb, target, &mrb_type, type) - -extern const struct mrb_data_type Color_type; -extern const struct mrb_data_type Rectangle_type; -extern const struct mrb_data_type Texture_type; -extern const struct mrb_data_type Sound_type; -extern const struct mrb_data_type Music_type; -extern const struct mrb_data_type Vector2_type; -extern const struct mrb_data_type NPatchInfo_type; -extern const struct mrb_data_type Font_type; - -void helper_texture_free(mrb_state*, void*); -void helper_sound_free(mrb_state*, void*); -void helper_music_free(mrb_state*, void*); -void helper_font_free(mrb_state*, void*); - -#endif /* end of include guard MRUBY_RAYLIB_TYPES_H */ - diff --git a/mrbgem.rake b/mrbgem.rake index 3e7f338..e2a03f0 100644 --- a/mrbgem.rake +++ b/mrbgem.rake @@ -1,6 +1,6 @@ -MRuby::Gem::Specification.new('mruby-raylib') do |spec| +MRuby::Gem::Specification.new('mruby-test') do |spec| spec.license = 'MIT' - spec.author = 'Tradam and Arnold' + spec.author = 'FelBind' # Add compile flags # spec.cc.flags << '' diff --git a/mrblib/color.rb b/mrblib/color.rb deleted file mode 100644 index c936f0d..0000000 --- a/mrblib/color.rb +++ /dev/null @@ -1,224 +0,0 @@ -module Raylib - - # In addition to creating custom colors, you can call - # any of the default 140 HTML colors(in addition to - # RayWhite and Clear) seen here: - # https://www.w3schools.com/colors/colors_names.asp - # - # When a default color is called it is created once and - # then stored for each future consecutive use. To call - # a color method simply use the ruby naming convention - # for method calls, for example to use BlueViolet you - # would do the following: - # - # +Rl::Color.blue_violet+ - # - # You can also add custom default colors by adding it to the ColorList hash so that they can be called the same way. - class Color - class << self - - # @!visibility private - def color_cache(color) - @color_cache ||= {} - if ColorList[color] - @color_cache[color] ||= Raylib::Color.new(ColorList[color][:r],ColorList[color][:g],ColorList[color][:b],ColorList[color][:a]||255) - else - raise 'Bad Colorname' - end - end - - # @!visibility private - def method_missing(method, *args) - if ColorList[method] - if args.empty? - self.color_cache(method) - else - raise ArgumentError.new "Expected no arguments" - end - else - super - end - end - - # @!visibility private - def respond_to_missing?(method, *args) - if ColorList[method] - true - else - super - end - end - - # Get a random color from the ColorList(excluding Clear) - # @return [Color] - def random - result = ColorList.keys.sample - while result == :clear - result = ColorList.keys.sample - end - self.send(result) - end - - def clone - Raylib::Color.new(r: self.r, - g: self.g, - b: self.b, - a: self.a) - end - end - - # Hash of all web colors, RayWhite, and Clear - ColorList = { - :clear=>{:r=>0, :g=>0, :b=>0, :a=>0}, - :ray_white=>{:r=>245, :g=>245, :b=>245}, - :alice_blue=>{:r=>240, :g=>248, :b=>255}, - :antique_white=>{:r=>250, :g=>235, :b=>215}, - :aqua=>{:r=>0, :g=>255, :b=>255}, - :aquamarine=>{:r=>127, :g=>255, :b=>212}, - :azure=>{:r=>240, :g=>255, :b=>255}, - :beige=>{:r=>245, :g=>245, :b=>220}, - :bisque=>{:r=>255, :g=>228, :b=>196}, - :black=>{:r=>0, :g=>0, :b=>0}, - :blanched_almond=>{:r=>255, :g=>235, :b=>205}, - :blue=>{:r=>0, :g=>0, :b=>255}, - :blue_violet=>{:r=>138, :g=>43, :b=>226}, - :brown=>{:r=>165, :g=>42, :b=>42}, - :burly_wood=>{:r=>222, :g=>184, :b=>135}, - :cadet_blue=>{:r=>95, :g=>158, :b=>160}, - :chartreuse=>{:r=>127, :g=>255, :b=>0}, - :chocolate=>{:r=>210, :g=>105, :b=>30}, - :coral=>{:r=>255, :g=>127, :b=>80}, - :cornflower_blue=>{:r=>100, :g=>149, :b=>237}, - :cornsilk=>{:r=>255, :g=>248, :b=>220}, - :crimson=>{:r=>220, :g=>20, :b=>60}, - :cyan=>{:r=>0, :g=>255, :b=>255}, - :dark_blue=>{:r=>0, :g=>0, :b=>139}, - :dark_cyan=>{:r=>0, :g=>139, :b=>139}, - :dark_golden_rod=>{:r=>184, :g=>134, :b=>11}, - :dark_gray=>{:r=>169, :g=>169, :b=>169}, - :dark_green=>{:r=>0, :g=>100, :b=>0}, - :dark_grey=>{:r=>169, :g=>169, :b=>169}, - :dark_khaki=>{:r=>189, :g=>183, :b=>107}, - :dark_magenta=>{:r=>139, :g=>0, :b=>139}, - :dark_olive_green=>{:r=>85, :g=>107, :b=>47}, - :dark_orange=>{:r=>255, :g=>140, :b=>0}, - :dark_orchid=>{:r=>153, :g=>50, :b=>204}, - :dark_red=>{:r=>139, :g=>0, :b=>0}, - :dark_salmon=>{:r=>233, :g=>150, :b=>122}, - :dark_sea_green=>{:r=>143, :g=>188, :b=>143}, - :dark_slate_blue=>{:r=>72, :g=>61, :b=>139}, - :dark_slate_gray=>{:r=>47, :g=>79, :b=>79}, - :dark_slate_grey=>{:r=>47, :g=>79, :b=>79}, - :dark_turquoise=>{:r=>0, :g=>206, :b=>209}, - :dark_violet=>{:r=>148, :g=>0, :b=>211}, - :deep_pink=>{:r=>255, :g=>20, :b=>147}, - :deep_sky_blue=>{:r=>0, :g=>191, :b=>255}, - :dim_gray=>{:r=>105, :g=>105, :b=>105}, - :dim_grey=>{:r=>105, :g=>105, :b=>105}, - :dodger_blue=>{:r=>30, :g=>144, :b=>255}, - :fire_brick=>{:r=>178, :g=>34, :b=>34}, - :floral_white=>{:r=>255, :g=>250, :b=>240}, - :forest_green=>{:r=>34, :g=>139, :b=>34}, - :fuchsia=>{:r=>255, :g=>0, :b=>255}, - :gainsboro=>{:r=>220, :g=>220, :b=>220}, - :ghost_white=>{:r=>248, :g=>248, :b=>255}, - :golden_rod=>{:r=>218, :g=>165, :b=>32}, - :gold=>{:r=>255, :g=>215, :b=>0}, - :gray=>{:r=>128, :g=>128, :b=>128}, - :green=>{:r=>0, :g=>128, :b=>0}, - :green_yellow=>{:r=>173, :g=>255, :b=>47}, - :grey=>{:r=>128, :g=>128, :b=>128}, - :honey_dew=>{:r=>240, :g=>255, :b=>240}, - :hot_pink=>{:r=>255, :g=>105, :b=>180}, - :indian_red=>{:r=>205, :g=>92, :b=>92}, - :indigo=>{:r=>75, :g=>0, :b=>130}, - :ivory=>{:r=>255, :g=>255, :b=>240}, - :khaki=>{:r=>240, :g=>230, :b=>140}, - :lavender_blush=>{:r=>255, :g=>240, :b=>245}, - :lavender=>{:r=>230, :g=>230, :b=>250}, - :lawn_green=>{:r=>124, :g=>252, :b=>0}, - :lemon_chiffon=>{:r=>255, :g=>250, :b=>205}, - :light_blue=>{:r=>173, :g=>216, :b=>230}, - :light_coral=>{:r=>240, :g=>128, :b=>128}, - :light_cyan=>{:r=>224, :g=>255, :b=>255}, - :light_golden_rod_yellow=>{:r=>250, :g=>250, :b=>210}, - :light_gray=>{:r=>211, :g=>211, :b=>211}, - :light_green=>{:r=>144, :g=>238, :b=>144}, - :light_grey=>{:r=>211, :g=>211, :b=>211}, - :light_pink=>{:r=>255, :g=>182, :b=>193}, - :light_salmon=>{:r=>255, :g=>160, :b=>122}, - :light_sea_green=>{:r=>32, :g=>178, :b=>170}, - :light_sky_blue=>{:r=>135, :g=>206, :b=>250}, - :light_slate_gray=>{:r=>119, :g=>136, :b=>153}, - :light_slate_grey=>{:r=>119, :g=>136, :b=>153}, - :light_steel_blue=>{:r=>176, :g=>196, :b=>222}, - :light_yellow=>{:r=>255, :g=>255, :b=>224}, - :lime=>{:r=>0, :g=>255, :b=>0}, - :lime_green=>{:r=>50, :g=>205, :b=>50}, - :linen=>{:r=>250, :g=>240, :b=>230}, - :magenta=>{:r=>255, :g=>0, :b=>255}, - :maroon=>{:r=>128, :g=>0, :b=>0}, - :medium_aquamarine=>{:r=>102, :g=>205, :b=>170}, - :medium_blue=>{:r=>0, :g=>0, :b=>205}, - :medium_orchid=>{:r=>186, :g=>85, :b=>211}, - :medium_purple=>{:r=>147, :g=>112, :b=>219}, - :medium_sea_green=>{:r=>60, :g=>179, :b=>113}, - :medium_slate_blue=>{:r=>123, :g=>104, :b=>238}, - :medium_spring_green=>{:r=>0, :g=>250, :b=>154}, - :medium_turquoise=>{:r=>72, :g=>209, :b=>204}, - :medium_violet_red=>{:r=>199, :g=>21, :b=>133}, - :midnight_blue=>{:r=>25, :g=>25, :b=>112}, - :mint_cream=>{:r=>245, :g=>255, :b=>250}, - :misty_rose=>{:r=>255, :g=>228, :b=>225}, - :moccasin=>{:r=>255, :g=>228, :b=>181}, - :navajo_white=>{:r=>255, :g=>222, :b=>173}, - :navy=>{:r=>0, :g=>0, :b=>128}, - :old_lace=>{:r=>253, :g=>245, :b=>230}, - :olive=>{:r=>128, :g=>128, :b=>0}, - :olive_drab=>{:r=>107, :g=>142, :b=>35}, - :orange=>{:r=>255, :g=>165, :b=>0}, - :orange_red=>{:r=>255, :g=>69, :b=>0}, - :orchid=>{:r=>218, :g=>112, :b=>214}, - :pale_golden_rod=>{:r=>238, :g=>232, :b=>170}, - :palegreen=>{:r=>152, :g=>251, :b=>152}, - :pale_turquoise=>{:r=>175, :g=>238, :b=>238}, - :pale_violet_red=>{:r=>219, :g=>112, :b=>147}, - :papaya_whip=>{:r=>255, :g=>239, :b=>213}, - :peach_puff=>{:r=>255, :g=>218, :b=>185}, - :peru=>{:r=>205, :g=>133, :b=>63}, - :pink=>{:r=>255, :g=>192, :b=>203}, - :plum=>{:r=>221, :g=>160, :b=>221}, - :powder_blue=>{:r=>176, :g=>224, :b=>230}, - :purple=>{:r=>128, :g=>0, :b=>128}, - :rebecca_purple=>{:r=>102, :g=>51, :b=>153}, - :red=>{:r=>255, :g=>0, :b=>0}, - :rosy_brown=>{:r=>188, :g=>143, :b=>143}, - :royal_blue=>{:r=>65, :g=>105, :b=>225}, - :saddle_brown=>{:r=>139, :g=>69, :b=>19}, - :salmon=>{:r=>250, :g=>128, :b=>114}, - :sandy_brown=>{:r=>244, :g=>164, :b=>96}, - :sea_green=>{:r=>46, :g=>139, :b=>87}, - :sea_shell=>{:r=>255, :g=>245, :b=>238}, - :sienna=>{:r=>160, :g=>82, :b=>45}, - :silver=>{:r=>192, :g=>192, :b=>192}, - :sky_blue=>{:r=>135, :g=>206, :b=>235}, - :slate_blue=>{:r=>106, :g=>90, :b=>205}, - :slate_gray=>{:r=>112, :g=>128, :b=>144}, - :slate_grey=>{:r=>112, :g=>128, :b=>144}, - :snow=>{:r=>255, :g=>250, :b=>250}, - :spring_green=>{:r=>0, :g=>255, :b=>127}, - :steel_blue=>{:r=>70, :g=>130, :b=>180}, - :tan=>{:r=>210, :g=>180, :b=>140}, - :teal=>{:r=>0, :g=>128, :b=>128}, - :thistle=>{:r=>216, :g=>191, :b=>216}, - :tomato=>{:r=>255, :g=>99, :b=>71}, - :turquoise=>{:r=>64, :g=>224, :b=>208}, - :violet=>{:r=>238, :g=>130, :b=>238}, - :wheat=>{:r=>245, :g=>222, :b=>179}, - :white=>{:r=>255, :g=>255, :b=>255}, - :white_smoke=>{:r=>245, :g=>245, :b=>245}, - :yellow=>{:r=>255, :g=>255, :b=>0}, - :yellow_green=>{:r=>154, :g=>205, :b=>50} - } - end -end diff --git a/mrblib/core.rb b/mrblib/core.rb deleted file mode 100644 index 21960c0..0000000 --- a/mrblib/core.rb +++ /dev/null @@ -1,30 +0,0 @@ -module Raylib - class Vector2 - class << self - # A vector initialized to (0,0). Useful when dont care about the vector - # value but you still need to pass it into a function/method and dont want - # to initialize a new one many times. - def default - @default ||= self.new(0, 0) - end - end - end - class << self - # The code block version of {Raylib.begin_scissor_mode} and {Raylib.end_scissor_mode} - # @overload scissor_mode(x: 0, y: 0, width: 10, height: 10, &block) - # @param x [Integer] - # @param y [Integer] - # @param width [Integer] - # @param height [Integer] - # @param block [Proc] The code to be executed in the scissor mode - def scissor_mode(*args, x: 0, y: 0, width: 10, height: 10, &block) - if args.length == 4 - self.begin_scissor_mode(args[0], args[1], args[2], args[3]) - else - self.begin_scissor_mode(x: x, y: y, width: width, height: height) - end - yield - self.end_scissor_mode - end - end -end diff --git a/mrblib/raylib.rb b/mrblib/raylib.rb deleted file mode 100644 index 41249be..0000000 --- a/mrblib/raylib.rb +++ /dev/null @@ -1,98 +0,0 @@ -Rl = Raylib - -# This is a raylib module -module Raylib - class Rectangle - def draw(color: Rl::Color.new(255,255,255,255)) - self._draw(color) - end - - def draw_lines(line_thick: 1, color: Rl::Color.new(255,255,255,255)) - self._draw_lines(line_thick, color) - end - end - - class Circle - attr_accessor :vector - attr_accessor :radius - - def initialize(x, y, radius) - self.vector = Vector2.new(x, y) - self.radius = radius - end - - def x - self.vector.x - end - - def y - self.vector.y - end - - def x=(x) - self.vector.x = x - end - - def y=(y) - self.vector.y = y - end - end - - - class << self - attr_accessor :defined_loop - attr_accessor :data_keys_pressed - - def while_window_open(&block) - self.defined_loop = block - if Raylib.platform == 'desktop' - while !Raylib.window_should_close? do - self.main_loop - end - elsif Raylib.platform == 'web' - Raylib.emscripten_set_main_loop - end - end - - def main_loop - self.data_keys_pressed = nil - self.defined_loop.call - end - - def draw_text(text:, x:, y:, font_size:, color: Rl::Color.new(255,255,255,255)) - self._draw_text(text, x, y, font_size, color) - end - - def draw_texture(texture:, x:, y:, tint: Rl::Color.new(255,255,255,255)) - texture.draw(x, y, tint) - end - - def draw_texture_ex(texture:, pos:, rotation: 0, scale: 1, tint: Rl::Color.new(255,255,255,255)) - self._draw_texture_ex(texture, pos, rotation, scale, tint) - end - - def draw_texture_pro(texture:, source_rec:, dest_rec:, origin: Rl::Vector.new(0,0), rotation: 0, tint: Rl::Color.new(255,255,255,255)) - self._draw_texture_pro(texture, source_rec, dest_rec, origin, rotation, tint) - end - - def keys_pressed - if self.data_keys_pressed - return self.data_keys_pressed - end - self.data_keys_pressed = [] - key = self._next_key_pressed - while key != 0 - self.data_keys_pressed.push key - key = self._next_key_pressed - end - self.data_keys_pressed - end - - def draw(clear_color: nil, &block) - self.clear_background(clear_color) if clear_color - self.begin_drawing - yield - self.end_drawing - end - end -end diff --git a/mrblib/shapes.rb b/mrblib/shapes.rb deleted file mode 100644 index 94c4bf1..0000000 --- a/mrblib/shapes.rb +++ /dev/null @@ -1,2 +0,0 @@ -module Raylib -end diff --git a/mrblib/text.rb b/mrblib/text.rb deleted file mode 100644 index d0ec4a1..0000000 --- a/mrblib/text.rb +++ /dev/null @@ -1,3 +0,0 @@ -class String - include Raylib::StringExtension -end diff --git a/mrblib/texture.rb b/mrblib/texture.rb deleted file mode 100644 index 4b5dea7..0000000 --- a/mrblib/texture.rb +++ /dev/null @@ -1,23 +0,0 @@ -module Raylib - class Texture - # @!visibility private - def h - self.height - end - - # @!visibility private - def h=(height) - self.height = height - end - - # @!visibility private - def w - self.width - end - - # @!visibility private - def w=(width) - self.width = width - end - end -end diff --git a/src/bind.c b/src/bind.c new file mode 100644 index 0000000..8b9c752 --- /dev/null +++ b/src/bind.c @@ -0,0 +1,17624 @@ +// "char **" is not a function return datatype that can be currently autobound. From function: "GetDirectoryFiles" + +// "char **" is not a function return datatype that can be currently autobound. From function: "GetDroppedFiles" + +// "TextureCubemap" is not a function return datatype that can be currently autobound. From function: "LoadTextureCubemap" + + + +#include <raylib.h> +#include <mruby.h> +#include <mruby/array.h> +#include <mruby/data.h> +#include <mruby/class.h> +#include <mruby/numeric.h> +#include <mruby/string.h> +#include <mruby/compile.h> +#include <stdlib.h> + + + + + static const struct mrb_data_type mrb_Color_struct = { + "Color", + mrb_free + }; + + +static mrb_value +mrb_Color_get_a(mrb_state* mrb, mrb_value self) { +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +return mrb_fixnum_value(struct_color->a); + +} + +static mrb_value +mrb_Color_set_a(mrb_state* mrb, mrb_value self) { +int parameter_a; + +mrb_get_args(mrb, "i", ¶meter_a); +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +struct_color->a = parameter_a; +return mrb_fixnum_value(parameter_a); + +} + +static mrb_value +mrb_Color_get_b(mrb_state* mrb, mrb_value self) { +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +return mrb_fixnum_value(struct_color->b); + +} + +static mrb_value +mrb_Color_set_b(mrb_state* mrb, mrb_value self) { +int parameter_b; + +mrb_get_args(mrb, "i", ¶meter_b); +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +struct_color->b = parameter_b; +return mrb_fixnum_value(parameter_b); + +} + +static mrb_value +mrb_Color_get_g(mrb_state* mrb, mrb_value self) { +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +return mrb_fixnum_value(struct_color->g); + +} + +static mrb_value +mrb_Color_set_g(mrb_state* mrb, mrb_value self) { +int parameter_g; + +mrb_get_args(mrb, "i", ¶meter_g); +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +struct_color->g = parameter_g; +return mrb_fixnum_value(parameter_g); + +} + +static mrb_value +mrb_Color_get_r(mrb_state* mrb, mrb_value self) { +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +return mrb_fixnum_value(struct_color->r); + +} + +static mrb_value +mrb_Color_set_r(mrb_state* mrb, mrb_value self) { +int parameter_r; + +mrb_get_args(mrb, "i", ¶meter_r); +Color *struct_color = DATA_GET_PTR(mrb, self, &mrb_Color_struct, Color); +struct_color->r = parameter_r; +return mrb_fixnum_value(parameter_r); + +} + +static mrb_value +mrb_Color_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *wrapped_value = (Color *)mrb_malloc(mrb, sizeof(Color)); +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "a"), +mrb_intern_lit(mrb, "b"), +mrb_intern_lit(mrb, "g"), +mrb_intern_lit(mrb, "r") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->a = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->b = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->g = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->r = mrb_as_int(mrb, kw_values[3]); + +} + mrb_data_init(self, wrapped_value, &mrb_Color_struct); +return self; +} + + + + static const struct mrb_data_type mrb_GlyphInfo_struct = { + "GlyphInfo", + mrb_free + }; + + +static mrb_value +mrb_GlyphInfo_get_advanceX(mrb_state* mrb, mrb_value self) { +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +return mrb_fixnum_value(struct_glyphinfo->advanceX); + +} + +static mrb_value +mrb_GlyphInfo_set_advanceX(mrb_state* mrb, mrb_value self) { +int parameter_advanceX; + +mrb_get_args(mrb, "i", ¶meter_advanceX); +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +struct_glyphinfo->advanceX = parameter_advanceX; +return mrb_fixnum_value(parameter_advanceX); + +} + +static mrb_value +mrb_GlyphInfo_get_offsetX(mrb_state* mrb, mrb_value self) { +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +return mrb_fixnum_value(struct_glyphinfo->offsetX); + +} + +static mrb_value +mrb_GlyphInfo_set_offsetX(mrb_state* mrb, mrb_value self) { +int parameter_offsetX; + +mrb_get_args(mrb, "i", ¶meter_offsetX); +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +struct_glyphinfo->offsetX = parameter_offsetX; +return mrb_fixnum_value(parameter_offsetX); + +} + +static mrb_value +mrb_GlyphInfo_get_offsetY(mrb_state* mrb, mrb_value self) { +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +return mrb_fixnum_value(struct_glyphinfo->offsetY); + +} + +static mrb_value +mrb_GlyphInfo_set_offsetY(mrb_state* mrb, mrb_value self) { +int parameter_offsetY; + +mrb_get_args(mrb, "i", ¶meter_offsetY); +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +struct_glyphinfo->offsetY = parameter_offsetY; +return mrb_fixnum_value(parameter_offsetY); + +} + +static mrb_value +mrb_GlyphInfo_get_value(mrb_state* mrb, mrb_value self) { +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +return mrb_fixnum_value(struct_glyphinfo->value); + +} + +static mrb_value +mrb_GlyphInfo_set_value(mrb_state* mrb, mrb_value self) { +int parameter_value; + +mrb_get_args(mrb, "i", ¶meter_value); +GlyphInfo *struct_glyphinfo = DATA_GET_PTR(mrb, self, &mrb_GlyphInfo_struct, GlyphInfo); +struct_glyphinfo->value = parameter_value; +return mrb_fixnum_value(parameter_value); + +} + +static mrb_value +mrb_GlyphInfo_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *glyphinfo_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_GlyphInfo_struct.struct_name); +GlyphInfo *wrapped_value = (GlyphInfo *)mrb_malloc(mrb, sizeof(GlyphInfo)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "advanceX"), +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "offsetX"), +mrb_intern_lit(mrb, "offsetY"), +mrb_intern_lit(mrb, "value") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->advanceX = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->offsetX = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->offsetY = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->value = mrb_as_int(mrb, kw_values[4]); + +} + mrb_data_init(self, wrapped_value, &mrb_GlyphInfo_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Mesh_struct = { + "Mesh", + mrb_free + }; + + +static mrb_value +mrb_Mesh_get_triangleCount(mrb_state* mrb, mrb_value self) { +Mesh *struct_mesh = DATA_GET_PTR(mrb, self, &mrb_Mesh_struct, Mesh); +return mrb_fixnum_value(struct_mesh->triangleCount); + +} + +static mrb_value +mrb_Mesh_set_triangleCount(mrb_state* mrb, mrb_value self) { +int parameter_triangleCount; + +mrb_get_args(mrb, "i", ¶meter_triangleCount); +Mesh *struct_mesh = DATA_GET_PTR(mrb, self, &mrb_Mesh_struct, Mesh); +struct_mesh->triangleCount = parameter_triangleCount; +return mrb_fixnum_value(parameter_triangleCount); + +} + +static mrb_value +mrb_Mesh_get_vaoId(mrb_state* mrb, mrb_value self) { +Mesh *struct_mesh = DATA_GET_PTR(mrb, self, &mrb_Mesh_struct, Mesh); +return mrb_fixnum_value(struct_mesh->vaoId); + +} + +static mrb_value +mrb_Mesh_set_vaoId(mrb_state* mrb, mrb_value self) { +int parameter_vaoId; + +mrb_get_args(mrb, "i", ¶meter_vaoId); +Mesh *struct_mesh = DATA_GET_PTR(mrb, self, &mrb_Mesh_struct, Mesh); +struct_mesh->vaoId = parameter_vaoId; +return mrb_fixnum_value(parameter_vaoId); + +} + +static mrb_value +mrb_Mesh_get_vertexCount(mrb_state* mrb, mrb_value self) { +Mesh *struct_mesh = DATA_GET_PTR(mrb, self, &mrb_Mesh_struct, Mesh); +return mrb_fixnum_value(struct_mesh->vertexCount); + +} + +static mrb_value +mrb_Mesh_set_vertexCount(mrb_state* mrb, mrb_value self) { +int parameter_vertexCount; + +mrb_get_args(mrb, "i", ¶meter_vertexCount); +Mesh *struct_mesh = DATA_GET_PTR(mrb, self, &mrb_Mesh_struct, Mesh); +struct_mesh->vertexCount = parameter_vertexCount; +return mrb_fixnum_value(parameter_vertexCount); + +} + +static mrb_value +mrb_Mesh_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *wrapped_value = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); +uint32_t kw_num = 15; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "animNormals"), +mrb_intern_lit(mrb, "animVertices"), +mrb_intern_lit(mrb, "boneIds"), +mrb_intern_lit(mrb, "boneWeights"), +mrb_intern_lit(mrb, "colors"), +mrb_intern_lit(mrb, "indices"), +mrb_intern_lit(mrb, "normals"), +mrb_intern_lit(mrb, "tangents"), +mrb_intern_lit(mrb, "texcoords"), +mrb_intern_lit(mrb, "texcoords2"), +mrb_intern_lit(mrb, "triangleCount"), +mrb_intern_lit(mrb, "vaoId"), +mrb_intern_lit(mrb, "vboId"), +mrb_intern_lit(mrb, "vertexCount"), +mrb_intern_lit(mrb, "vertices") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[10])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->triangleCount = mrb_as_int(mrb, kw_values[10]); + +} + +if (mrb_undef_p(kw_values[11])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->vaoId = mrb_as_int(mrb, kw_values[11]); + +} + +if (mrb_undef_p(kw_values[13])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->vertexCount = mrb_as_int(mrb, kw_values[13]); + +} + mrb_data_init(self, wrapped_value, &mrb_Mesh_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Font_struct = { + "Font", + mrb_free + }; + + +static mrb_value +mrb_Font_get_baseSize(mrb_state* mrb, mrb_value self) { +Font *struct_font = DATA_GET_PTR(mrb, self, &mrb_Font_struct, Font); +return mrb_fixnum_value(struct_font->baseSize); + +} + +static mrb_value +mrb_Font_set_baseSize(mrb_state* mrb, mrb_value self) { +int parameter_baseSize; + +mrb_get_args(mrb, "i", ¶meter_baseSize); +Font *struct_font = DATA_GET_PTR(mrb, self, &mrb_Font_struct, Font); +struct_font->baseSize = parameter_baseSize; +return mrb_fixnum_value(parameter_baseSize); + +} + +static mrb_value +mrb_Font_get_glyphCount(mrb_state* mrb, mrb_value self) { +Font *struct_font = DATA_GET_PTR(mrb, self, &mrb_Font_struct, Font); +return mrb_fixnum_value(struct_font->glyphCount); + +} + +static mrb_value +mrb_Font_set_glyphCount(mrb_state* mrb, mrb_value self) { +int parameter_glyphCount; + +mrb_get_args(mrb, "i", ¶meter_glyphCount); +Font *struct_font = DATA_GET_PTR(mrb, self, &mrb_Font_struct, Font); +struct_font->glyphCount = parameter_glyphCount; +return mrb_fixnum_value(parameter_glyphCount); + +} + +static mrb_value +mrb_Font_get_glyphPadding(mrb_state* mrb, mrb_value self) { +Font *struct_font = DATA_GET_PTR(mrb, self, &mrb_Font_struct, Font); +return mrb_fixnum_value(struct_font->glyphPadding); + +} + +static mrb_value +mrb_Font_set_glyphPadding(mrb_state* mrb, mrb_value self) { +int parameter_glyphPadding; + +mrb_get_args(mrb, "i", ¶meter_glyphPadding); +Font *struct_font = DATA_GET_PTR(mrb, self, &mrb_Font_struct, Font); +struct_font->glyphPadding = parameter_glyphPadding; +return mrb_fixnum_value(parameter_glyphPadding); + +} + +static mrb_value +mrb_Font_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *font_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Font_struct.struct_name); +Font *wrapped_value = (Font *)mrb_malloc(mrb, sizeof(Font)); +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "baseSize"), +mrb_intern_lit(mrb, "glyphCount"), +mrb_intern_lit(mrb, "glyphPadding"), +mrb_intern_lit(mrb, "glyphs"), +mrb_intern_lit(mrb, "recs"), +mrb_intern_lit(mrb, "texture") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->baseSize = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->glyphCount = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->glyphPadding = mrb_as_int(mrb, kw_values[2]); + +} + mrb_data_init(self, wrapped_value, &mrb_Font_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Model_struct = { + "Model", + mrb_free + }; + + +static mrb_value +mrb_Model_get_boneCount(mrb_state* mrb, mrb_value self) { +Model *struct_model = DATA_GET_PTR(mrb, self, &mrb_Model_struct, Model); +return mrb_fixnum_value(struct_model->boneCount); + +} + +static mrb_value +mrb_Model_set_boneCount(mrb_state* mrb, mrb_value self) { +int parameter_boneCount; + +mrb_get_args(mrb, "i", ¶meter_boneCount); +Model *struct_model = DATA_GET_PTR(mrb, self, &mrb_Model_struct, Model); +struct_model->boneCount = parameter_boneCount; +return mrb_fixnum_value(parameter_boneCount); + +} + +static mrb_value +mrb_Model_get_materialCount(mrb_state* mrb, mrb_value self) { +Model *struct_model = DATA_GET_PTR(mrb, self, &mrb_Model_struct, Model); +return mrb_fixnum_value(struct_model->materialCount); + +} + +static mrb_value +mrb_Model_set_materialCount(mrb_state* mrb, mrb_value self) { +int parameter_materialCount; + +mrb_get_args(mrb, "i", ¶meter_materialCount); +Model *struct_model = DATA_GET_PTR(mrb, self, &mrb_Model_struct, Model); +struct_model->materialCount = parameter_materialCount; +return mrb_fixnum_value(parameter_materialCount); + +} + +static mrb_value +mrb_Model_get_meshCount(mrb_state* mrb, mrb_value self) { +Model *struct_model = DATA_GET_PTR(mrb, self, &mrb_Model_struct, Model); +return mrb_fixnum_value(struct_model->meshCount); + +} + +static mrb_value +mrb_Model_set_meshCount(mrb_state* mrb, mrb_value self) { +int parameter_meshCount; + +mrb_get_args(mrb, "i", ¶meter_meshCount); +Model *struct_model = DATA_GET_PTR(mrb, self, &mrb_Model_struct, Model); +struct_model->meshCount = parameter_meshCount; +return mrb_fixnum_value(parameter_meshCount); + +} + +static mrb_value +mrb_Model_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *model_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Model_struct.struct_name); +Model *wrapped_value = (Model *)mrb_malloc(mrb, sizeof(Model)); +uint32_t kw_num = 9; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "bindPose"), +mrb_intern_lit(mrb, "boneCount"), +mrb_intern_lit(mrb, "bones"), +mrb_intern_lit(mrb, "materialCount"), +mrb_intern_lit(mrb, "materials"), +mrb_intern_lit(mrb, "meshCount"), +mrb_intern_lit(mrb, "meshMaterial"), +mrb_intern_lit(mrb, "meshes"), +mrb_intern_lit(mrb, "transform") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->boneCount = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->materialCount = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->meshCount = mrb_as_int(mrb, kw_values[5]); + +} + mrb_data_init(self, wrapped_value, &mrb_Model_struct); +return self; +} + + + + static const struct mrb_data_type mrb_ModelAnimation_struct = { + "ModelAnimation", + mrb_free + }; + + +static mrb_value +mrb_ModelAnimation_get_boneCount(mrb_state* mrb, mrb_value self) { +ModelAnimation *struct_modelanimation = DATA_GET_PTR(mrb, self, &mrb_ModelAnimation_struct, ModelAnimation); +return mrb_fixnum_value(struct_modelanimation->boneCount); + +} + +static mrb_value +mrb_ModelAnimation_set_boneCount(mrb_state* mrb, mrb_value self) { +int parameter_boneCount; + +mrb_get_args(mrb, "i", ¶meter_boneCount); +ModelAnimation *struct_modelanimation = DATA_GET_PTR(mrb, self, &mrb_ModelAnimation_struct, ModelAnimation); +struct_modelanimation->boneCount = parameter_boneCount; +return mrb_fixnum_value(parameter_boneCount); + +} + +static mrb_value +mrb_ModelAnimation_get_frameCount(mrb_state* mrb, mrb_value self) { +ModelAnimation *struct_modelanimation = DATA_GET_PTR(mrb, self, &mrb_ModelAnimation_struct, ModelAnimation); +return mrb_fixnum_value(struct_modelanimation->frameCount); + +} + +static mrb_value +mrb_ModelAnimation_set_frameCount(mrb_state* mrb, mrb_value self) { +int parameter_frameCount; + +mrb_get_args(mrb, "i", ¶meter_frameCount); +ModelAnimation *struct_modelanimation = DATA_GET_PTR(mrb, self, &mrb_ModelAnimation_struct, ModelAnimation); +struct_modelanimation->frameCount = parameter_frameCount; +return mrb_fixnum_value(parameter_frameCount); + +} + +static mrb_value +mrb_ModelAnimation_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *modelanimation_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_ModelAnimation_struct.struct_name); +ModelAnimation *wrapped_value = (ModelAnimation *)mrb_malloc(mrb, sizeof(ModelAnimation)); +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "boneCount"), +mrb_intern_lit(mrb, "bones"), +mrb_intern_lit(mrb, "frameCount"), +mrb_intern_lit(mrb, "framePoses") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->boneCount = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->frameCount = mrb_as_int(mrb, kw_values[2]); + +} + mrb_data_init(self, wrapped_value, &mrb_ModelAnimation_struct); +return self; +} + + + + static const struct mrb_data_type mrb_NPatchInfo_struct = { + "NPatchInfo", + mrb_free + }; + + +static mrb_value +mrb_NPatchInfo_get_bottom(mrb_state* mrb, mrb_value self) { +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +return mrb_fixnum_value(struct_npatchinfo->bottom); + +} + +static mrb_value +mrb_NPatchInfo_set_bottom(mrb_state* mrb, mrb_value self) { +int parameter_bottom; + +mrb_get_args(mrb, "i", ¶meter_bottom); +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +struct_npatchinfo->bottom = parameter_bottom; +return mrb_fixnum_value(parameter_bottom); + +} + +static mrb_value +mrb_NPatchInfo_get_layout(mrb_state* mrb, mrb_value self) { +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +return mrb_fixnum_value(struct_npatchinfo->layout); + +} + +static mrb_value +mrb_NPatchInfo_set_layout(mrb_state* mrb, mrb_value self) { +int parameter_layout; + +mrb_get_args(mrb, "i", ¶meter_layout); +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +struct_npatchinfo->layout = parameter_layout; +return mrb_fixnum_value(parameter_layout); + +} + +static mrb_value +mrb_NPatchInfo_get_left(mrb_state* mrb, mrb_value self) { +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +return mrb_fixnum_value(struct_npatchinfo->left); + +} + +static mrb_value +mrb_NPatchInfo_set_left(mrb_state* mrb, mrb_value self) { +int parameter_left; + +mrb_get_args(mrb, "i", ¶meter_left); +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +struct_npatchinfo->left = parameter_left; +return mrb_fixnum_value(parameter_left); + +} + +static mrb_value +mrb_NPatchInfo_get_right(mrb_state* mrb, mrb_value self) { +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +return mrb_fixnum_value(struct_npatchinfo->right); + +} + +static mrb_value +mrb_NPatchInfo_set_right(mrb_state* mrb, mrb_value self) { +int parameter_right; + +mrb_get_args(mrb, "i", ¶meter_right); +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +struct_npatchinfo->right = parameter_right; +return mrb_fixnum_value(parameter_right); + +} + +static mrb_value +mrb_NPatchInfo_get_top(mrb_state* mrb, mrb_value self) { +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +return mrb_fixnum_value(struct_npatchinfo->top); + +} + +static mrb_value +mrb_NPatchInfo_set_top(mrb_state* mrb, mrb_value self) { +int parameter_top; + +mrb_get_args(mrb, "i", ¶meter_top); +NPatchInfo *struct_npatchinfo = DATA_GET_PTR(mrb, self, &mrb_NPatchInfo_struct, NPatchInfo); +struct_npatchinfo->top = parameter_top; +return mrb_fixnum_value(parameter_top); + +} + +static mrb_value +mrb_NPatchInfo_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *npatchinfo_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_NPatchInfo_struct.struct_name); +NPatchInfo *wrapped_value = (NPatchInfo *)mrb_malloc(mrb, sizeof(NPatchInfo)); +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "bottom"), +mrb_intern_lit(mrb, "layout"), +mrb_intern_lit(mrb, "left"), +mrb_intern_lit(mrb, "right"), +mrb_intern_lit(mrb, "source"), +mrb_intern_lit(mrb, "top") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->bottom = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->layout = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->left = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->right = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->top = mrb_as_int(mrb, kw_values[5]); + +} + mrb_data_init(self, wrapped_value, &mrb_NPatchInfo_struct); +return self; +} + + + + static const struct mrb_data_type mrb_AudioStream_struct = { + "AudioStream", + mrb_free + }; + + +static mrb_value +mrb_AudioStream_get_channels(mrb_state* mrb, mrb_value self) { +AudioStream *struct_audiostream = DATA_GET_PTR(mrb, self, &mrb_AudioStream_struct, AudioStream); +return mrb_fixnum_value(struct_audiostream->channels); + +} + +static mrb_value +mrb_AudioStream_set_channels(mrb_state* mrb, mrb_value self) { +int parameter_channels; + +mrb_get_args(mrb, "i", ¶meter_channels); +AudioStream *struct_audiostream = DATA_GET_PTR(mrb, self, &mrb_AudioStream_struct, AudioStream); +struct_audiostream->channels = parameter_channels; +return mrb_fixnum_value(parameter_channels); + +} + +static mrb_value +mrb_AudioStream_get_sampleRate(mrb_state* mrb, mrb_value self) { +AudioStream *struct_audiostream = DATA_GET_PTR(mrb, self, &mrb_AudioStream_struct, AudioStream); +return mrb_fixnum_value(struct_audiostream->sampleRate); + +} + +static mrb_value +mrb_AudioStream_set_sampleRate(mrb_state* mrb, mrb_value self) { +int parameter_sampleRate; + +mrb_get_args(mrb, "i", ¶meter_sampleRate); +AudioStream *struct_audiostream = DATA_GET_PTR(mrb, self, &mrb_AudioStream_struct, AudioStream); +struct_audiostream->sampleRate = parameter_sampleRate; +return mrb_fixnum_value(parameter_sampleRate); + +} + +static mrb_value +mrb_AudioStream_get_sampleSize(mrb_state* mrb, mrb_value self) { +AudioStream *struct_audiostream = DATA_GET_PTR(mrb, self, &mrb_AudioStream_struct, AudioStream); +return mrb_fixnum_value(struct_audiostream->sampleSize); + +} + +static mrb_value +mrb_AudioStream_set_sampleSize(mrb_state* mrb, mrb_value self) { +int parameter_sampleSize; + +mrb_get_args(mrb, "i", ¶meter_sampleSize); +AudioStream *struct_audiostream = DATA_GET_PTR(mrb, self, &mrb_AudioStream_struct, AudioStream); +struct_audiostream->sampleSize = parameter_sampleSize; +return mrb_fixnum_value(parameter_sampleSize); + +} + +static mrb_value +mrb_AudioStream_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *audiostream_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_AudioStream_struct.struct_name); +AudioStream *wrapped_value = (AudioStream *)mrb_malloc(mrb, sizeof(AudioStream)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "buffer"), +mrb_intern_lit(mrb, "channels"), +mrb_intern_lit(mrb, "processor"), +mrb_intern_lit(mrb, "sampleRate"), +mrb_intern_lit(mrb, "sampleSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->channels = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->sampleRate = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->sampleSize = mrb_as_int(mrb, kw_values[4]); + +} + mrb_data_init(self, wrapped_value, &mrb_AudioStream_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Wave_struct = { + "Wave", + mrb_free + }; + + +static mrb_value +mrb_Wave_get_channels(mrb_state* mrb, mrb_value self) { +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +return mrb_fixnum_value(struct_wave->channels); + +} + +static mrb_value +mrb_Wave_set_channels(mrb_state* mrb, mrb_value self) { +int parameter_channels; + +mrb_get_args(mrb, "i", ¶meter_channels); +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +struct_wave->channels = parameter_channels; +return mrb_fixnum_value(parameter_channels); + +} + +static mrb_value +mrb_Wave_get_frameCount(mrb_state* mrb, mrb_value self) { +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +return mrb_fixnum_value(struct_wave->frameCount); + +} + +static mrb_value +mrb_Wave_set_frameCount(mrb_state* mrb, mrb_value self) { +int parameter_frameCount; + +mrb_get_args(mrb, "i", ¶meter_frameCount); +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +struct_wave->frameCount = parameter_frameCount; +return mrb_fixnum_value(parameter_frameCount); + +} + +static mrb_value +mrb_Wave_get_sampleRate(mrb_state* mrb, mrb_value self) { +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +return mrb_fixnum_value(struct_wave->sampleRate); + +} + +static mrb_value +mrb_Wave_set_sampleRate(mrb_state* mrb, mrb_value self) { +int parameter_sampleRate; + +mrb_get_args(mrb, "i", ¶meter_sampleRate); +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +struct_wave->sampleRate = parameter_sampleRate; +return mrb_fixnum_value(parameter_sampleRate); + +} + +static mrb_value +mrb_Wave_get_sampleSize(mrb_state* mrb, mrb_value self) { +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +return mrb_fixnum_value(struct_wave->sampleSize); + +} + +static mrb_value +mrb_Wave_set_sampleSize(mrb_state* mrb, mrb_value self) { +int parameter_sampleSize; + +mrb_get_args(mrb, "i", ¶meter_sampleSize); +Wave *struct_wave = DATA_GET_PTR(mrb, self, &mrb_Wave_struct, Wave); +struct_wave->sampleSize = parameter_sampleSize; +return mrb_fixnum_value(parameter_sampleSize); + +} + +static mrb_value +mrb_Wave_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *wave_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Wave_struct.struct_name); +Wave *wrapped_value = (Wave *)mrb_malloc(mrb, sizeof(Wave)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "channels"), +mrb_intern_lit(mrb, "data"), +mrb_intern_lit(mrb, "frameCount"), +mrb_intern_lit(mrb, "sampleRate"), +mrb_intern_lit(mrb, "sampleSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->channels = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->frameCount = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->sampleRate = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->sampleSize = mrb_as_int(mrb, kw_values[4]); + +} + mrb_data_init(self, wrapped_value, &mrb_Wave_struct); +return self; +} + + + + static const struct mrb_data_type mrb_VrDeviceInfo_struct = { + "VrDeviceInfo", + mrb_free + }; + + +static mrb_value +mrb_VrDeviceInfo_get_eyeToScreenDistance(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_float_value(mrb, struct_vrdeviceinfo->eyeToScreenDistance); + +} + +static mrb_value +mrb_VrDeviceInfo_set_eyeToScreenDistance(mrb_state* mrb, mrb_value self) { +float parameter_eyeToScreenDistance; + +mrb_get_args(mrb, "f", ¶meter_eyeToScreenDistance); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->eyeToScreenDistance = parameter_eyeToScreenDistance; +return mrb_float_value(mrb, parameter_eyeToScreenDistance); + +} + +static mrb_value +mrb_VrDeviceInfo_get_hResolution(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_fixnum_value(struct_vrdeviceinfo->hResolution); + +} + +static mrb_value +mrb_VrDeviceInfo_set_hResolution(mrb_state* mrb, mrb_value self) { +int parameter_hResolution; + +mrb_get_args(mrb, "i", ¶meter_hResolution); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->hResolution = parameter_hResolution; +return mrb_fixnum_value(parameter_hResolution); + +} + +static mrb_value +mrb_VrDeviceInfo_get_hScreenSize(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_float_value(mrb, struct_vrdeviceinfo->hScreenSize); + +} + +static mrb_value +mrb_VrDeviceInfo_set_hScreenSize(mrb_state* mrb, mrb_value self) { +float parameter_hScreenSize; + +mrb_get_args(mrb, "f", ¶meter_hScreenSize); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->hScreenSize = parameter_hScreenSize; +return mrb_float_value(mrb, parameter_hScreenSize); + +} + +static mrb_value +mrb_VrDeviceInfo_get_interpupillaryDistance(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_float_value(mrb, struct_vrdeviceinfo->interpupillaryDistance); + +} + +static mrb_value +mrb_VrDeviceInfo_set_interpupillaryDistance(mrb_state* mrb, mrb_value self) { +float parameter_interpupillaryDistance; + +mrb_get_args(mrb, "f", ¶meter_interpupillaryDistance); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->interpupillaryDistance = parameter_interpupillaryDistance; +return mrb_float_value(mrb, parameter_interpupillaryDistance); + +} + +static mrb_value +mrb_VrDeviceInfo_get_lensSeparationDistance(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_float_value(mrb, struct_vrdeviceinfo->lensSeparationDistance); + +} + +static mrb_value +mrb_VrDeviceInfo_set_lensSeparationDistance(mrb_state* mrb, mrb_value self) { +float parameter_lensSeparationDistance; + +mrb_get_args(mrb, "f", ¶meter_lensSeparationDistance); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->lensSeparationDistance = parameter_lensSeparationDistance; +return mrb_float_value(mrb, parameter_lensSeparationDistance); + +} + +static mrb_value +mrb_VrDeviceInfo_get_vResolution(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_fixnum_value(struct_vrdeviceinfo->vResolution); + +} + +static mrb_value +mrb_VrDeviceInfo_set_vResolution(mrb_state* mrb, mrb_value self) { +int parameter_vResolution; + +mrb_get_args(mrb, "i", ¶meter_vResolution); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->vResolution = parameter_vResolution; +return mrb_fixnum_value(parameter_vResolution); + +} + +static mrb_value +mrb_VrDeviceInfo_get_vScreenCenter(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_float_value(mrb, struct_vrdeviceinfo->vScreenCenter); + +} + +static mrb_value +mrb_VrDeviceInfo_set_vScreenCenter(mrb_state* mrb, mrb_value self) { +float parameter_vScreenCenter; + +mrb_get_args(mrb, "f", ¶meter_vScreenCenter); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->vScreenCenter = parameter_vScreenCenter; +return mrb_float_value(mrb, parameter_vScreenCenter); + +} + +static mrb_value +mrb_VrDeviceInfo_get_vScreenSize(mrb_state* mrb, mrb_value self) { +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +return mrb_float_value(mrb, struct_vrdeviceinfo->vScreenSize); + +} + +static mrb_value +mrb_VrDeviceInfo_set_vScreenSize(mrb_state* mrb, mrb_value self) { +float parameter_vScreenSize; + +mrb_get_args(mrb, "f", ¶meter_vScreenSize); +VrDeviceInfo *struct_vrdeviceinfo = DATA_GET_PTR(mrb, self, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct_vrdeviceinfo->vScreenSize = parameter_vScreenSize; +return mrb_float_value(mrb, parameter_vScreenSize); + +} + +static mrb_value +mrb_VrDeviceInfo_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vrdeviceinfo_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_VrDeviceInfo_struct.struct_name); +VrDeviceInfo *wrapped_value = (VrDeviceInfo *)mrb_malloc(mrb, sizeof(VrDeviceInfo)); +uint32_t kw_num = 10; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "chromaAbCorrection"), +mrb_intern_lit(mrb, "eyeToScreenDistance"), +mrb_intern_lit(mrb, "hResolution"), +mrb_intern_lit(mrb, "hScreenSize"), +mrb_intern_lit(mrb, "interpupillaryDistance"), +mrb_intern_lit(mrb, "lensDistortionValues"), +mrb_intern_lit(mrb, "lensSeparationDistance"), +mrb_intern_lit(mrb, "vResolution"), +mrb_intern_lit(mrb, "vScreenCenter"), +mrb_intern_lit(mrb, "vScreenSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->eyeToScreenDistance = mrb_as_float(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->hResolution = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->hScreenSize = mrb_as_float(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->interpupillaryDistance = mrb_as_float(mrb, kw_values[4]); + +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->lensSeparationDistance = mrb_as_float(mrb, kw_values[6]); + +} + +if (mrb_undef_p(kw_values[7])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->vResolution = mrb_as_int(mrb, kw_values[7]); + +} + +if (mrb_undef_p(kw_values[8])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->vScreenCenter = mrb_as_float(mrb, kw_values[8]); + +} + +if (mrb_undef_p(kw_values[9])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->vScreenSize = mrb_as_float(mrb, kw_values[9]); + +} + mrb_data_init(self, wrapped_value, &mrb_VrDeviceInfo_struct); +return self; +} + + + + static const struct mrb_data_type mrb_MaterialMap_struct = { + "MaterialMap", + mrb_free + }; + + +static mrb_value +mrb_MaterialMap_get_value(mrb_state* mrb, mrb_value self) { +MaterialMap *struct_materialmap = DATA_GET_PTR(mrb, self, &mrb_MaterialMap_struct, MaterialMap); +return mrb_float_value(mrb, struct_materialmap->value); + +} + +static mrb_value +mrb_MaterialMap_set_value(mrb_state* mrb, mrb_value self) { +float parameter_value; + +mrb_get_args(mrb, "f", ¶meter_value); +MaterialMap *struct_materialmap = DATA_GET_PTR(mrb, self, &mrb_MaterialMap_struct, MaterialMap); +struct_materialmap->value = parameter_value; +return mrb_float_value(mrb, parameter_value); + +} + +static mrb_value +mrb_MaterialMap_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *materialmap_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_MaterialMap_struct.struct_name); +MaterialMap *wrapped_value = (MaterialMap *)mrb_malloc(mrb, sizeof(MaterialMap)); +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "color"), +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "value") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->value = mrb_as_float(mrb, kw_values[2]); + +} + mrb_data_init(self, wrapped_value, &mrb_MaterialMap_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Music_struct = { + "Music", + mrb_free + }; + + +static mrb_value +mrb_Music_get_ctxType(mrb_state* mrb, mrb_value self) { +Music *struct_music = DATA_GET_PTR(mrb, self, &mrb_Music_struct, Music); +return mrb_fixnum_value(struct_music->ctxType); + +} + +static mrb_value +mrb_Music_set_ctxType(mrb_state* mrb, mrb_value self) { +int parameter_ctxType; + +mrb_get_args(mrb, "i", ¶meter_ctxType); +Music *struct_music = DATA_GET_PTR(mrb, self, &mrb_Music_struct, Music); +struct_music->ctxType = parameter_ctxType; +return mrb_fixnum_value(parameter_ctxType); + +} + +static mrb_value +mrb_Music_get_frameCount(mrb_state* mrb, mrb_value self) { +Music *struct_music = DATA_GET_PTR(mrb, self, &mrb_Music_struct, Music); +return mrb_fixnum_value(struct_music->frameCount); + +} + +static mrb_value +mrb_Music_set_frameCount(mrb_state* mrb, mrb_value self) { +int parameter_frameCount; + +mrb_get_args(mrb, "i", ¶meter_frameCount); +Music *struct_music = DATA_GET_PTR(mrb, self, &mrb_Music_struct, Music); +struct_music->frameCount = parameter_frameCount; +return mrb_fixnum_value(parameter_frameCount); + +} + +static mrb_value +mrb_Music_get_looping(mrb_state* mrb, mrb_value self) { +Music *struct_music = DATA_GET_PTR(mrb, self, &mrb_Music_struct, Music); +return mrb_bool_value(struct_music->looping); + +} + +static mrb_value +mrb_Music_set_looping(mrb_state* mrb, mrb_value self) { +bool parameter_looping; + +mrb_get_args(mrb, "b", ¶meter_looping); +Music *struct_music = DATA_GET_PTR(mrb, self, &mrb_Music_struct, Music); +struct_music->looping = parameter_looping; +return mrb_bool_value(parameter_looping); + +} + +static mrb_value +mrb_Music_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *music_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Music_struct.struct_name); +Music *wrapped_value = (Music *)mrb_malloc(mrb, sizeof(Music)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ctxData"), +mrb_intern_lit(mrb, "ctxType"), +mrb_intern_lit(mrb, "frameCount"), +mrb_intern_lit(mrb, "looping"), +mrb_intern_lit(mrb, "stream") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->ctxType = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->frameCount = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->looping = mrb_as_int(mrb, kw_values[3]); + +} + mrb_data_init(self, wrapped_value, &mrb_Music_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Image_struct = { + "Image", + mrb_free + }; + + +static mrb_value +mrb_Image_get_format(mrb_state* mrb, mrb_value self) { +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +return mrb_fixnum_value(struct_image->format); + +} + +static mrb_value +mrb_Image_set_format(mrb_state* mrb, mrb_value self) { +int parameter_format; + +mrb_get_args(mrb, "i", ¶meter_format); +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +struct_image->format = parameter_format; +return mrb_fixnum_value(parameter_format); + +} + +static mrb_value +mrb_Image_get_height(mrb_state* mrb, mrb_value self) { +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +return mrb_fixnum_value(struct_image->height); + +} + +static mrb_value +mrb_Image_set_height(mrb_state* mrb, mrb_value self) { +int parameter_height; + +mrb_get_args(mrb, "i", ¶meter_height); +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +struct_image->height = parameter_height; +return mrb_fixnum_value(parameter_height); + +} + +static mrb_value +mrb_Image_get_mipmaps(mrb_state* mrb, mrb_value self) { +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +return mrb_fixnum_value(struct_image->mipmaps); + +} + +static mrb_value +mrb_Image_set_mipmaps(mrb_state* mrb, mrb_value self) { +int parameter_mipmaps; + +mrb_get_args(mrb, "i", ¶meter_mipmaps); +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +struct_image->mipmaps = parameter_mipmaps; +return mrb_fixnum_value(parameter_mipmaps); + +} + +static mrb_value +mrb_Image_get_width(mrb_state* mrb, mrb_value self) { +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +return mrb_fixnum_value(struct_image->width); + +} + +static mrb_value +mrb_Image_set_width(mrb_state* mrb, mrb_value self) { +int parameter_width; + +mrb_get_args(mrb, "i", ¶meter_width); +Image *struct_image = DATA_GET_PTR(mrb, self, &mrb_Image_struct, Image); +struct_image->width = parameter_width; +return mrb_fixnum_value(parameter_width); + +} + +static mrb_value +mrb_Image_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *wrapped_value = (Image *)mrb_malloc(mrb, sizeof(Image)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "data"), +mrb_intern_lit(mrb, "format"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "mipmaps"), +mrb_intern_lit(mrb, "width") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->format = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->height = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->mipmaps = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->width = mrb_as_int(mrb, kw_values[4]); + +} + mrb_data_init(self, wrapped_value, &mrb_Image_struct); +return self; +} + + + + static const struct mrb_data_type mrb_RenderTexture_struct = { + "RenderTexture", + mrb_free + }; + + +static mrb_value +mrb_RenderTexture_get_id(mrb_state* mrb, mrb_value self) { +RenderTexture *struct_rendertexture = DATA_GET_PTR(mrb, self, &mrb_RenderTexture_struct, RenderTexture); +return mrb_fixnum_value(struct_rendertexture->id); + +} + +static mrb_value +mrb_RenderTexture_set_id(mrb_state* mrb, mrb_value self) { +int parameter_id; + +mrb_get_args(mrb, "i", ¶meter_id); +RenderTexture *struct_rendertexture = DATA_GET_PTR(mrb, self, &mrb_RenderTexture_struct, RenderTexture); +struct_rendertexture->id = parameter_id; +return mrb_fixnum_value(parameter_id); + +} + +static mrb_value +mrb_RenderTexture_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *rendertexture_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RenderTexture_struct.struct_name); +RenderTexture *wrapped_value = (RenderTexture *)mrb_malloc(mrb, sizeof(RenderTexture)); +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "depth"), +mrb_intern_lit(mrb, "id"), +mrb_intern_lit(mrb, "texture") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->id = mrb_as_int(mrb, kw_values[1]); + +} + mrb_data_init(self, wrapped_value, &mrb_RenderTexture_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Ray_struct = { + "Ray", + mrb_free + }; + + +static mrb_value +mrb_Ray_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *ray_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Ray_struct.struct_name); +Ray *wrapped_value = (Ray *)mrb_malloc(mrb, sizeof(Ray)); +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "direction"), +mrb_intern_lit(mrb, "position") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + mrb_data_init(self, wrapped_value, &mrb_Ray_struct); +return self; +} + + + + static const struct mrb_data_type mrb_RayCollision_struct = { + "RayCollision", + mrb_free + }; + + +static mrb_value +mrb_RayCollision_get_distance(mrb_state* mrb, mrb_value self) { +RayCollision *struct_raycollision = DATA_GET_PTR(mrb, self, &mrb_RayCollision_struct, RayCollision); +return mrb_float_value(mrb, struct_raycollision->distance); + +} + +static mrb_value +mrb_RayCollision_set_distance(mrb_state* mrb, mrb_value self) { +float parameter_distance; + +mrb_get_args(mrb, "f", ¶meter_distance); +RayCollision *struct_raycollision = DATA_GET_PTR(mrb, self, &mrb_RayCollision_struct, RayCollision); +struct_raycollision->distance = parameter_distance; +return mrb_float_value(mrb, parameter_distance); + +} + +static mrb_value +mrb_RayCollision_get_hit(mrb_state* mrb, mrb_value self) { +RayCollision *struct_raycollision = DATA_GET_PTR(mrb, self, &mrb_RayCollision_struct, RayCollision); +return mrb_bool_value(struct_raycollision->hit); + +} + +static mrb_value +mrb_RayCollision_set_hit(mrb_state* mrb, mrb_value self) { +bool parameter_hit; + +mrb_get_args(mrb, "b", ¶meter_hit); +RayCollision *struct_raycollision = DATA_GET_PTR(mrb, self, &mrb_RayCollision_struct, RayCollision); +struct_raycollision->hit = parameter_hit; +return mrb_bool_value(parameter_hit); + +} + +static mrb_value +mrb_RayCollision_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *raycollision_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RayCollision_struct.struct_name); +RayCollision *wrapped_value = (RayCollision *)mrb_malloc(mrb, sizeof(RayCollision)); +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "distance"), +mrb_intern_lit(mrb, "hit"), +mrb_intern_lit(mrb, "normal"), +mrb_intern_lit(mrb, "point") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->distance = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->hit = mrb_as_int(mrb, kw_values[1]); + +} + mrb_data_init(self, wrapped_value, &mrb_RayCollision_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Texture_struct = { + "Texture", + mrb_free + }; + + +static mrb_value +mrb_Texture_get_format(mrb_state* mrb, mrb_value self) { +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +return mrb_fixnum_value(struct_texture->format); + +} + +static mrb_value +mrb_Texture_set_format(mrb_state* mrb, mrb_value self) { +int parameter_format; + +mrb_get_args(mrb, "i", ¶meter_format); +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +struct_texture->format = parameter_format; +return mrb_fixnum_value(parameter_format); + +} + +static mrb_value +mrb_Texture_get_height(mrb_state* mrb, mrb_value self) { +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +return mrb_fixnum_value(struct_texture->height); + +} + +static mrb_value +mrb_Texture_set_height(mrb_state* mrb, mrb_value self) { +int parameter_height; + +mrb_get_args(mrb, "i", ¶meter_height); +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +struct_texture->height = parameter_height; +return mrb_fixnum_value(parameter_height); + +} + +static mrb_value +mrb_Texture_get_id(mrb_state* mrb, mrb_value self) { +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +return mrb_fixnum_value(struct_texture->id); + +} + +static mrb_value +mrb_Texture_set_id(mrb_state* mrb, mrb_value self) { +int parameter_id; + +mrb_get_args(mrb, "i", ¶meter_id); +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +struct_texture->id = parameter_id; +return mrb_fixnum_value(parameter_id); + +} + +static mrb_value +mrb_Texture_get_mipmaps(mrb_state* mrb, mrb_value self) { +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +return mrb_fixnum_value(struct_texture->mipmaps); + +} + +static mrb_value +mrb_Texture_set_mipmaps(mrb_state* mrb, mrb_value self) { +int parameter_mipmaps; + +mrb_get_args(mrb, "i", ¶meter_mipmaps); +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +struct_texture->mipmaps = parameter_mipmaps; +return mrb_fixnum_value(parameter_mipmaps); + +} + +static mrb_value +mrb_Texture_get_width(mrb_state* mrb, mrb_value self) { +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +return mrb_fixnum_value(struct_texture->width); + +} + +static mrb_value +mrb_Texture_set_width(mrb_state* mrb, mrb_value self) { +int parameter_width; + +mrb_get_args(mrb, "i", ¶meter_width); +Texture *struct_texture = DATA_GET_PTR(mrb, self, &mrb_Texture_struct, Texture); +struct_texture->width = parameter_width; +return mrb_fixnum_value(parameter_width); + +} + +static mrb_value +mrb_Texture_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *texture_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Texture_struct.struct_name); +Texture *wrapped_value = (Texture *)mrb_malloc(mrb, sizeof(Texture)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "format"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "id"), +mrb_intern_lit(mrb, "mipmaps"), +mrb_intern_lit(mrb, "width") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->format = mrb_as_int(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->height = mrb_as_int(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->id = mrb_as_int(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->mipmaps = mrb_as_int(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->width = mrb_as_int(mrb, kw_values[4]); + +} + mrb_data_init(self, wrapped_value, &mrb_Texture_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Camera3D_struct = { + "Camera3D", + mrb_free + }; + + +static mrb_value +mrb_Camera3D_get_fovy(mrb_state* mrb, mrb_value self) { +Camera3D *struct_camera3d = DATA_GET_PTR(mrb, self, &mrb_Camera3D_struct, Camera3D); +return mrb_float_value(mrb, struct_camera3d->fovy); + +} + +static mrb_value +mrb_Camera3D_set_fovy(mrb_state* mrb, mrb_value self) { +float parameter_fovy; + +mrb_get_args(mrb, "f", ¶meter_fovy); +Camera3D *struct_camera3d = DATA_GET_PTR(mrb, self, &mrb_Camera3D_struct, Camera3D); +struct_camera3d->fovy = parameter_fovy; +return mrb_float_value(mrb, parameter_fovy); + +} + +static mrb_value +mrb_Camera3D_get_projection(mrb_state* mrb, mrb_value self) { +Camera3D *struct_camera3d = DATA_GET_PTR(mrb, self, &mrb_Camera3D_struct, Camera3D); +return mrb_fixnum_value(struct_camera3d->projection); + +} + +static mrb_value +mrb_Camera3D_set_projection(mrb_state* mrb, mrb_value self) { +int parameter_projection; + +mrb_get_args(mrb, "i", ¶meter_projection); +Camera3D *struct_camera3d = DATA_GET_PTR(mrb, self, &mrb_Camera3D_struct, Camera3D); +struct_camera3d->projection = parameter_projection; +return mrb_fixnum_value(parameter_projection); + +} + +static mrb_value +mrb_Camera3D_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *camera3d_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Camera3D_struct.struct_name); +Camera3D *wrapped_value = (Camera3D *)mrb_malloc(mrb, sizeof(Camera3D)); +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fovy"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "projection"), +mrb_intern_lit(mrb, "target"), +mrb_intern_lit(mrb, "up") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->fovy = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->projection = mrb_as_int(mrb, kw_values[2]); + +} + mrb_data_init(self, wrapped_value, &mrb_Camera3D_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Sound_struct = { + "Sound", + mrb_free + }; + + +static mrb_value +mrb_Sound_get_frameCount(mrb_state* mrb, mrb_value self) { +Sound *struct_sound = DATA_GET_PTR(mrb, self, &mrb_Sound_struct, Sound); +return mrb_fixnum_value(struct_sound->frameCount); + +} + +static mrb_value +mrb_Sound_set_frameCount(mrb_state* mrb, mrb_value self) { +int parameter_frameCount; + +mrb_get_args(mrb, "i", ¶meter_frameCount); +Sound *struct_sound = DATA_GET_PTR(mrb, self, &mrb_Sound_struct, Sound); +struct_sound->frameCount = parameter_frameCount; +return mrb_fixnum_value(parameter_frameCount); + +} + +static mrb_value +mrb_Sound_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *sound_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Sound_struct.struct_name); +Sound *wrapped_value = (Sound *)mrb_malloc(mrb, sizeof(Sound)); +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "frameCount"), +mrb_intern_lit(mrb, "stream") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->frameCount = mrb_as_int(mrb, kw_values[0]); + +} + mrb_data_init(self, wrapped_value, &mrb_Sound_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Rectangle_struct = { + "Rectangle", + mrb_free + }; + + +static mrb_value +mrb_Rectangle_get_height(mrb_state* mrb, mrb_value self) { +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +return mrb_float_value(mrb, struct_rectangle->height); + +} + +static mrb_value +mrb_Rectangle_set_height(mrb_state* mrb, mrb_value self) { +float parameter_height; + +mrb_get_args(mrb, "f", ¶meter_height); +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +struct_rectangle->height = parameter_height; +return mrb_float_value(mrb, parameter_height); + +} + +static mrb_value +mrb_Rectangle_get_width(mrb_state* mrb, mrb_value self) { +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +return mrb_float_value(mrb, struct_rectangle->width); + +} + +static mrb_value +mrb_Rectangle_set_width(mrb_state* mrb, mrb_value self) { +float parameter_width; + +mrb_get_args(mrb, "f", ¶meter_width); +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +struct_rectangle->width = parameter_width; +return mrb_float_value(mrb, parameter_width); + +} + +static mrb_value +mrb_Rectangle_get_x(mrb_state* mrb, mrb_value self) { +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +return mrb_float_value(mrb, struct_rectangle->x); + +} + +static mrb_value +mrb_Rectangle_set_x(mrb_state* mrb, mrb_value self) { +float parameter_x; + +mrb_get_args(mrb, "f", ¶meter_x); +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +struct_rectangle->x = parameter_x; +return mrb_float_value(mrb, parameter_x); + +} + +static mrb_value +mrb_Rectangle_get_y(mrb_state* mrb, mrb_value self) { +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +return mrb_float_value(mrb, struct_rectangle->y); + +} + +static mrb_value +mrb_Rectangle_set_y(mrb_state* mrb, mrb_value self) { +float parameter_y; + +mrb_get_args(mrb, "f", ¶meter_y); +Rectangle *struct_rectangle = DATA_GET_PTR(mrb, self, &mrb_Rectangle_struct, Rectangle); +struct_rectangle->y = parameter_y; +return mrb_float_value(mrb, parameter_y); + +} + +static mrb_value +mrb_Rectangle_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *rectangle_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Rectangle_struct.struct_name); +Rectangle *wrapped_value = (Rectangle *)mrb_malloc(mrb, sizeof(Rectangle)); +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->height = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->width = mrb_as_float(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->x = mrb_as_float(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->y = mrb_as_float(mrb, kw_values[3]); + +} + mrb_data_init(self, wrapped_value, &mrb_Rectangle_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Shader_struct = { + "Shader", + mrb_free + }; + + +static mrb_value +mrb_Shader_get_id(mrb_state* mrb, mrb_value self) { +Shader *struct_shader = DATA_GET_PTR(mrb, self, &mrb_Shader_struct, Shader); +return mrb_fixnum_value(struct_shader->id); + +} + +static mrb_value +mrb_Shader_set_id(mrb_state* mrb, mrb_value self) { +int parameter_id; + +mrb_get_args(mrb, "i", ¶meter_id); +Shader *struct_shader = DATA_GET_PTR(mrb, self, &mrb_Shader_struct, Shader); +struct_shader->id = parameter_id; +return mrb_fixnum_value(parameter_id); + +} + +static mrb_value +mrb_Shader_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *shader_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Shader_struct.struct_name); +Shader *wrapped_value = (Shader *)mrb_malloc(mrb, sizeof(Shader)); +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "id"), +mrb_intern_lit(mrb, "locs") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->id = mrb_as_int(mrb, kw_values[0]); + +} + mrb_data_init(self, wrapped_value, &mrb_Shader_struct); +return self; +} + + + + static const struct mrb_data_type mrb_VrStereoConfig_struct = { + "VrStereoConfig", + mrb_free + }; + + +static mrb_value +mrb_VrStereoConfig_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vrstereoconfig_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_VrStereoConfig_struct.struct_name); +VrStereoConfig *wrapped_value = (VrStereoConfig *)mrb_malloc(mrb, sizeof(VrStereoConfig)); +uint32_t kw_num = 8; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "leftLensCenter"), +mrb_intern_lit(mrb, "leftScreenCenter"), +mrb_intern_lit(mrb, "projection"), +mrb_intern_lit(mrb, "rightLensCenter"), +mrb_intern_lit(mrb, "rightScreenCenter"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "scaleIn"), +mrb_intern_lit(mrb, "viewOffset") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + mrb_data_init(self, wrapped_value, &mrb_VrStereoConfig_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Matrix_struct = { + "Matrix", + mrb_free + }; + + +static mrb_value +mrb_Matrix_get_m0(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m0); + +} + +static mrb_value +mrb_Matrix_set_m0(mrb_state* mrb, mrb_value self) { +float parameter_m0; + +mrb_get_args(mrb, "f", ¶meter_m0); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m0 = parameter_m0; +return mrb_float_value(mrb, parameter_m0); + +} + +static mrb_value +mrb_Matrix_get_m1(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m1); + +} + +static mrb_value +mrb_Matrix_set_m1(mrb_state* mrb, mrb_value self) { +float parameter_m1; + +mrb_get_args(mrb, "f", ¶meter_m1); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m1 = parameter_m1; +return mrb_float_value(mrb, parameter_m1); + +} + +static mrb_value +mrb_Matrix_get_m10(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m10); + +} + +static mrb_value +mrb_Matrix_set_m10(mrb_state* mrb, mrb_value self) { +float parameter_m10; + +mrb_get_args(mrb, "f", ¶meter_m10); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m10 = parameter_m10; +return mrb_float_value(mrb, parameter_m10); + +} + +static mrb_value +mrb_Matrix_get_m11(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m11); + +} + +static mrb_value +mrb_Matrix_set_m11(mrb_state* mrb, mrb_value self) { +float parameter_m11; + +mrb_get_args(mrb, "f", ¶meter_m11); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m11 = parameter_m11; +return mrb_float_value(mrb, parameter_m11); + +} + +static mrb_value +mrb_Matrix_get_m12(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m12); + +} + +static mrb_value +mrb_Matrix_set_m12(mrb_state* mrb, mrb_value self) { +float parameter_m12; + +mrb_get_args(mrb, "f", ¶meter_m12); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m12 = parameter_m12; +return mrb_float_value(mrb, parameter_m12); + +} + +static mrb_value +mrb_Matrix_get_m13(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m13); + +} + +static mrb_value +mrb_Matrix_set_m13(mrb_state* mrb, mrb_value self) { +float parameter_m13; + +mrb_get_args(mrb, "f", ¶meter_m13); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m13 = parameter_m13; +return mrb_float_value(mrb, parameter_m13); + +} + +static mrb_value +mrb_Matrix_get_m14(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m14); + +} + +static mrb_value +mrb_Matrix_set_m14(mrb_state* mrb, mrb_value self) { +float parameter_m14; + +mrb_get_args(mrb, "f", ¶meter_m14); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m14 = parameter_m14; +return mrb_float_value(mrb, parameter_m14); + +} + +static mrb_value +mrb_Matrix_get_m15(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m15); + +} + +static mrb_value +mrb_Matrix_set_m15(mrb_state* mrb, mrb_value self) { +float parameter_m15; + +mrb_get_args(mrb, "f", ¶meter_m15); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m15 = parameter_m15; +return mrb_float_value(mrb, parameter_m15); + +} + +static mrb_value +mrb_Matrix_get_m2(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m2); + +} + +static mrb_value +mrb_Matrix_set_m2(mrb_state* mrb, mrb_value self) { +float parameter_m2; + +mrb_get_args(mrb, "f", ¶meter_m2); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m2 = parameter_m2; +return mrb_float_value(mrb, parameter_m2); + +} + +static mrb_value +mrb_Matrix_get_m3(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m3); + +} + +static mrb_value +mrb_Matrix_set_m3(mrb_state* mrb, mrb_value self) { +float parameter_m3; + +mrb_get_args(mrb, "f", ¶meter_m3); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m3 = parameter_m3; +return mrb_float_value(mrb, parameter_m3); + +} + +static mrb_value +mrb_Matrix_get_m4(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m4); + +} + +static mrb_value +mrb_Matrix_set_m4(mrb_state* mrb, mrb_value self) { +float parameter_m4; + +mrb_get_args(mrb, "f", ¶meter_m4); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m4 = parameter_m4; +return mrb_float_value(mrb, parameter_m4); + +} + +static mrb_value +mrb_Matrix_get_m5(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m5); + +} + +static mrb_value +mrb_Matrix_set_m5(mrb_state* mrb, mrb_value self) { +float parameter_m5; + +mrb_get_args(mrb, "f", ¶meter_m5); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m5 = parameter_m5; +return mrb_float_value(mrb, parameter_m5); + +} + +static mrb_value +mrb_Matrix_get_m6(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m6); + +} + +static mrb_value +mrb_Matrix_set_m6(mrb_state* mrb, mrb_value self) { +float parameter_m6; + +mrb_get_args(mrb, "f", ¶meter_m6); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m6 = parameter_m6; +return mrb_float_value(mrb, parameter_m6); + +} + +static mrb_value +mrb_Matrix_get_m7(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m7); + +} + +static mrb_value +mrb_Matrix_set_m7(mrb_state* mrb, mrb_value self) { +float parameter_m7; + +mrb_get_args(mrb, "f", ¶meter_m7); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m7 = parameter_m7; +return mrb_float_value(mrb, parameter_m7); + +} + +static mrb_value +mrb_Matrix_get_m8(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m8); + +} + +static mrb_value +mrb_Matrix_set_m8(mrb_state* mrb, mrb_value self) { +float parameter_m8; + +mrb_get_args(mrb, "f", ¶meter_m8); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m8 = parameter_m8; +return mrb_float_value(mrb, parameter_m8); + +} + +static mrb_value +mrb_Matrix_get_m9(mrb_state* mrb, mrb_value self) { +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +return mrb_float_value(mrb, struct_matrix->m9); + +} + +static mrb_value +mrb_Matrix_set_m9(mrb_state* mrb, mrb_value self) { +float parameter_m9; + +mrb_get_args(mrb, "f", ¶meter_m9); +Matrix *struct_matrix = DATA_GET_PTR(mrb, self, &mrb_Matrix_struct, Matrix); +struct_matrix->m9 = parameter_m9; +return mrb_float_value(mrb, parameter_m9); + +} + +static mrb_value +mrb_Matrix_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *matrix_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Matrix_struct.struct_name); +Matrix *wrapped_value = (Matrix *)mrb_malloc(mrb, sizeof(Matrix)); +uint32_t kw_num = 16; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "m0"), +mrb_intern_lit(mrb, "m1"), +mrb_intern_lit(mrb, "m10"), +mrb_intern_lit(mrb, "m11"), +mrb_intern_lit(mrb, "m12"), +mrb_intern_lit(mrb, "m13"), +mrb_intern_lit(mrb, "m14"), +mrb_intern_lit(mrb, "m15"), +mrb_intern_lit(mrb, "m2"), +mrb_intern_lit(mrb, "m3"), +mrb_intern_lit(mrb, "m4"), +mrb_intern_lit(mrb, "m5"), +mrb_intern_lit(mrb, "m6"), +mrb_intern_lit(mrb, "m7"), +mrb_intern_lit(mrb, "m8"), +mrb_intern_lit(mrb, "m9") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m0 = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m1 = mrb_as_float(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m10 = mrb_as_float(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m11 = mrb_as_float(mrb, kw_values[3]); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m12 = mrb_as_float(mrb, kw_values[4]); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m13 = mrb_as_float(mrb, kw_values[5]); + +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m14 = mrb_as_float(mrb, kw_values[6]); + +} + +if (mrb_undef_p(kw_values[7])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m15 = mrb_as_float(mrb, kw_values[7]); + +} + +if (mrb_undef_p(kw_values[8])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m2 = mrb_as_float(mrb, kw_values[8]); + +} + +if (mrb_undef_p(kw_values[9])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m3 = mrb_as_float(mrb, kw_values[9]); + +} + +if (mrb_undef_p(kw_values[10])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m4 = mrb_as_float(mrb, kw_values[10]); + +} + +if (mrb_undef_p(kw_values[11])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m5 = mrb_as_float(mrb, kw_values[11]); + +} + +if (mrb_undef_p(kw_values[12])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m6 = mrb_as_float(mrb, kw_values[12]); + +} + +if (mrb_undef_p(kw_values[13])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m7 = mrb_as_float(mrb, kw_values[13]); + +} + +if (mrb_undef_p(kw_values[14])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m8 = mrb_as_float(mrb, kw_values[14]); + +} + +if (mrb_undef_p(kw_values[15])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->m9 = mrb_as_float(mrb, kw_values[15]); + +} + mrb_data_init(self, wrapped_value, &mrb_Matrix_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Material_struct = { + "Material", + mrb_free + }; + + +static mrb_value +mrb_Material_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *material_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Material_struct.struct_name); +Material *wrapped_value = (Material *)mrb_malloc(mrb, sizeof(Material)); +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "maps"), +mrb_intern_lit(mrb, "params"), +mrb_intern_lit(mrb, "shader") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + mrb_data_init(self, wrapped_value, &mrb_Material_struct); +return self; +} + + + + static const struct mrb_data_type mrb_BoundingBox_struct = { + "BoundingBox", + mrb_free + }; + + +static mrb_value +mrb_BoundingBox_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *boundingbox_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_BoundingBox_struct.struct_name); +BoundingBox *wrapped_value = (BoundingBox *)mrb_malloc(mrb, sizeof(BoundingBox)); +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "max"), +mrb_intern_lit(mrb, "min") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + mrb_data_init(self, wrapped_value, &mrb_BoundingBox_struct); +return self; +} + + + + static const struct mrb_data_type mrb_BoneInfo_struct = { + "BoneInfo", + mrb_free + }; + + +static mrb_value +mrb_BoneInfo_get_parent(mrb_state* mrb, mrb_value self) { +BoneInfo *struct_boneinfo = DATA_GET_PTR(mrb, self, &mrb_BoneInfo_struct, BoneInfo); +return mrb_fixnum_value(struct_boneinfo->parent); + +} + +static mrb_value +mrb_BoneInfo_set_parent(mrb_state* mrb, mrb_value self) { +int parameter_parent; + +mrb_get_args(mrb, "i", ¶meter_parent); +BoneInfo *struct_boneinfo = DATA_GET_PTR(mrb, self, &mrb_BoneInfo_struct, BoneInfo); +struct_boneinfo->parent = parameter_parent; +return mrb_fixnum_value(parameter_parent); + +} + +static mrb_value +mrb_BoneInfo_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *boneinfo_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_BoneInfo_struct.struct_name); +BoneInfo *wrapped_value = (BoneInfo *)mrb_malloc(mrb, sizeof(BoneInfo)); +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "name"), +mrb_intern_lit(mrb, "parent") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->parent = mrb_as_int(mrb, kw_values[1]); + +} + mrb_data_init(self, wrapped_value, &mrb_BoneInfo_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Camera2D_struct = { + "Camera2D", + mrb_free + }; + + +static mrb_value +mrb_Camera2D_get_rotation(mrb_state* mrb, mrb_value self) { +Camera2D *struct_camera2d = DATA_GET_PTR(mrb, self, &mrb_Camera2D_struct, Camera2D); +return mrb_float_value(mrb, struct_camera2d->rotation); + +} + +static mrb_value +mrb_Camera2D_set_rotation(mrb_state* mrb, mrb_value self) { +float parameter_rotation; + +mrb_get_args(mrb, "f", ¶meter_rotation); +Camera2D *struct_camera2d = DATA_GET_PTR(mrb, self, &mrb_Camera2D_struct, Camera2D); +struct_camera2d->rotation = parameter_rotation; +return mrb_float_value(mrb, parameter_rotation); + +} + +static mrb_value +mrb_Camera2D_get_zoom(mrb_state* mrb, mrb_value self) { +Camera2D *struct_camera2d = DATA_GET_PTR(mrb, self, &mrb_Camera2D_struct, Camera2D); +return mrb_float_value(mrb, struct_camera2d->zoom); + +} + +static mrb_value +mrb_Camera2D_set_zoom(mrb_state* mrb, mrb_value self) { +float parameter_zoom; + +mrb_get_args(mrb, "f", ¶meter_zoom); +Camera2D *struct_camera2d = DATA_GET_PTR(mrb, self, &mrb_Camera2D_struct, Camera2D); +struct_camera2d->zoom = parameter_zoom; +return mrb_float_value(mrb, parameter_zoom); + +} + +static mrb_value +mrb_Camera2D_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *camera2d_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Camera2D_struct.struct_name); +Camera2D *wrapped_value = (Camera2D *)mrb_malloc(mrb, sizeof(Camera2D)); +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "offset"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "target"), +mrb_intern_lit(mrb, "zoom") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->rotation = mrb_as_float(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->zoom = mrb_as_float(mrb, kw_values[3]); + +} + mrb_data_init(self, wrapped_value, &mrb_Camera2D_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Transform_struct = { + "Transform", + mrb_free + }; + + +static mrb_value +mrb_Transform_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *transform_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Transform_struct.struct_name); +Transform *wrapped_value = (Transform *)mrb_malloc(mrb, sizeof(Transform)); +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "translation") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + mrb_data_init(self, wrapped_value, &mrb_Transform_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Vector4_struct = { + "Vector4", + mrb_free + }; + + +static mrb_value +mrb_Vector4_get_w(mrb_state* mrb, mrb_value self) { +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +return mrb_float_value(mrb, struct_vector4->w); + +} + +static mrb_value +mrb_Vector4_set_w(mrb_state* mrb, mrb_value self) { +float parameter_w; + +mrb_get_args(mrb, "f", ¶meter_w); +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +struct_vector4->w = parameter_w; +return mrb_float_value(mrb, parameter_w); + +} + +static mrb_value +mrb_Vector4_get_x(mrb_state* mrb, mrb_value self) { +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +return mrb_float_value(mrb, struct_vector4->x); + +} + +static mrb_value +mrb_Vector4_set_x(mrb_state* mrb, mrb_value self) { +float parameter_x; + +mrb_get_args(mrb, "f", ¶meter_x); +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +struct_vector4->x = parameter_x; +return mrb_float_value(mrb, parameter_x); + +} + +static mrb_value +mrb_Vector4_get_y(mrb_state* mrb, mrb_value self) { +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +return mrb_float_value(mrb, struct_vector4->y); + +} + +static mrb_value +mrb_Vector4_set_y(mrb_state* mrb, mrb_value self) { +float parameter_y; + +mrb_get_args(mrb, "f", ¶meter_y); +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +struct_vector4->y = parameter_y; +return mrb_float_value(mrb, parameter_y); + +} + +static mrb_value +mrb_Vector4_get_z(mrb_state* mrb, mrb_value self) { +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +return mrb_float_value(mrb, struct_vector4->z); + +} + +static mrb_value +mrb_Vector4_set_z(mrb_state* mrb, mrb_value self) { +float parameter_z; + +mrb_get_args(mrb, "f", ¶meter_z); +Vector4 *struct_vector4 = DATA_GET_PTR(mrb, self, &mrb_Vector4_struct, Vector4); +struct_vector4->z = parameter_z; +return mrb_float_value(mrb, parameter_z); + +} + +static mrb_value +mrb_Vector4_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector4_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector4_struct.struct_name); +Vector4 *wrapped_value = (Vector4 *)mrb_malloc(mrb, sizeof(Vector4)); +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "w"), +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y"), +mrb_intern_lit(mrb, "z") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->w = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->x = mrb_as_float(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->y = mrb_as_float(mrb, kw_values[2]); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->z = mrb_as_float(mrb, kw_values[3]); + +} + mrb_data_init(self, wrapped_value, &mrb_Vector4_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Vector2_struct = { + "Vector2", + mrb_free + }; + + +static mrb_value +mrb_Vector2_get_x(mrb_state* mrb, mrb_value self) { +Vector2 *struct_vector2 = DATA_GET_PTR(mrb, self, &mrb_Vector2_struct, Vector2); +return mrb_float_value(mrb, struct_vector2->x); + +} + +static mrb_value +mrb_Vector2_set_x(mrb_state* mrb, mrb_value self) { +float parameter_x; + +mrb_get_args(mrb, "f", ¶meter_x); +Vector2 *struct_vector2 = DATA_GET_PTR(mrb, self, &mrb_Vector2_struct, Vector2); +struct_vector2->x = parameter_x; +return mrb_float_value(mrb, parameter_x); + +} + +static mrb_value +mrb_Vector2_get_y(mrb_state* mrb, mrb_value self) { +Vector2 *struct_vector2 = DATA_GET_PTR(mrb, self, &mrb_Vector2_struct, Vector2); +return mrb_float_value(mrb, struct_vector2->y); + +} + +static mrb_value +mrb_Vector2_set_y(mrb_state* mrb, mrb_value self) { +float parameter_y; + +mrb_get_args(mrb, "f", ¶meter_y); +Vector2 *struct_vector2 = DATA_GET_PTR(mrb, self, &mrb_Vector2_struct, Vector2); +struct_vector2->y = parameter_y; +return mrb_float_value(mrb, parameter_y); + +} + +static mrb_value +mrb_Vector2_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *wrapped_value = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->x = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->y = mrb_as_float(mrb, kw_values[1]); + +} + mrb_data_init(self, wrapped_value, &mrb_Vector2_struct); +return self; +} + + + + static const struct mrb_data_type mrb_Vector3_struct = { + "Vector3", + mrb_free + }; + + +static mrb_value +mrb_Vector3_get_x(mrb_state* mrb, mrb_value self) { +Vector3 *struct_vector3 = DATA_GET_PTR(mrb, self, &mrb_Vector3_struct, Vector3); +return mrb_float_value(mrb, struct_vector3->x); + +} + +static mrb_value +mrb_Vector3_set_x(mrb_state* mrb, mrb_value self) { +float parameter_x; + +mrb_get_args(mrb, "f", ¶meter_x); +Vector3 *struct_vector3 = DATA_GET_PTR(mrb, self, &mrb_Vector3_struct, Vector3); +struct_vector3->x = parameter_x; +return mrb_float_value(mrb, parameter_x); + +} + +static mrb_value +mrb_Vector3_get_y(mrb_state* mrb, mrb_value self) { +Vector3 *struct_vector3 = DATA_GET_PTR(mrb, self, &mrb_Vector3_struct, Vector3); +return mrb_float_value(mrb, struct_vector3->y); + +} + +static mrb_value +mrb_Vector3_set_y(mrb_state* mrb, mrb_value self) { +float parameter_y; + +mrb_get_args(mrb, "f", ¶meter_y); +Vector3 *struct_vector3 = DATA_GET_PTR(mrb, self, &mrb_Vector3_struct, Vector3); +struct_vector3->y = parameter_y; +return mrb_float_value(mrb, parameter_y); + +} + +static mrb_value +mrb_Vector3_get_z(mrb_state* mrb, mrb_value self) { +Vector3 *struct_vector3 = DATA_GET_PTR(mrb, self, &mrb_Vector3_struct, Vector3); +return mrb_float_value(mrb, struct_vector3->z); + +} + +static mrb_value +mrb_Vector3_set_z(mrb_state* mrb, mrb_value self) { +float parameter_z; + +mrb_get_args(mrb, "f", ¶meter_z); +Vector3 *struct_vector3 = DATA_GET_PTR(mrb, self, &mrb_Vector3_struct, Vector3); +struct_vector3->z = parameter_z; +return mrb_float_value(mrb, parameter_z); + +} + +static mrb_value +mrb_Vector3_initialize(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector3_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector3_struct.struct_name); +Vector3 *wrapped_value = (Vector3 *)mrb_malloc(mrb, sizeof(Vector3)); +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y"), +mrb_intern_lit(mrb, "z") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->x = mrb_as_float(mrb, kw_values[0]); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->y = mrb_as_float(mrb, kw_values[1]); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +wrapped_value->z = mrb_as_float(mrb, kw_values[2]); + +} + mrb_data_init(self, wrapped_value, &mrb_Vector3_struct); +return self; +} + +//void BeginBlendMode +static mrb_value +mrb_BeginBlendMode(mrb_state* mrb, mrb_value self) { +mrb_int parameter_mode; + +mrb_get_args(mrb, "i", ¶meter_mode); + +BeginBlendMode(parameter_mode); +return mrb_nil_value(); +} + +//void BeginDrawing +static mrb_value +mrb_BeginDrawing(mrb_state* mrb, mrb_value self) { + +BeginDrawing(); +return mrb_nil_value(); +} + +//void BeginMode2D +static mrb_value +mrb_BeginMode2D(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_camera; + +mrb_get_args(mrb, "o", ¶meter_mrb_camera); +Camera2D *parameter_camera; +parameter_camera = DATA_GET_PTR(mrb, parameter_mrb_camera, &mrb_Camera2D_struct, Camera2D); + +BeginMode2D(*parameter_camera); +return mrb_nil_value(); +} + +//void BeginMode3D +static mrb_value +mrb_BeginMode3D(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_camera; + +mrb_get_args(mrb, "o", ¶meter_mrb_camera); +Camera3D *parameter_camera; +parameter_camera = DATA_GET_PTR(mrb, parameter_mrb_camera, &mrb_Camera3D_struct, Camera3D); + +BeginMode3D(*parameter_camera); +return mrb_nil_value(); +} + +//void BeginScissorMode +static mrb_value +mrb_BeginScissorMode(mrb_state* mrb, mrb_value self) { +int parameter_x; +int parameter_y; +int parameter_width; +int parameter_height; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_x = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_y = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[3]); +} + + +BeginScissorMode(parameter_x, parameter_y, parameter_width, parameter_height); +return mrb_nil_value(); +} + +//void BeginShaderMode +static mrb_value +mrb_BeginShaderMode(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_shader; + +mrb_get_args(mrb, "o", ¶meter_mrb_shader); +Shader *parameter_shader; +parameter_shader = DATA_GET_PTR(mrb, parameter_mrb_shader, &mrb_Shader_struct, Shader); + +BeginShaderMode(*parameter_shader); +return mrb_nil_value(); +} + +//void BeginTextureMode +static mrb_value +mrb_BeginTextureMode(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_target; + +mrb_get_args(mrb, "o", ¶meter_mrb_target); +RenderTexture *parameter_target; +parameter_target = DATA_GET_PTR(mrb, parameter_mrb_target, &mrb_RenderTexture_struct, RenderTexture); + +BeginTextureMode(*parameter_target); +return mrb_nil_value(); +} + +//void BeginVrStereoMode +static mrb_value +mrb_BeginVrStereoMode(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_config; + +mrb_get_args(mrb, "o", ¶meter_mrb_config); +VrStereoConfig *parameter_config; +parameter_config = DATA_GET_PTR(mrb, parameter_mrb_config, &mrb_VrStereoConfig_struct, VrStereoConfig); + +BeginVrStereoMode(*parameter_config); +return mrb_nil_value(); +} + +//bool ChangeDirectory +static mrb_value +mrb_ChangeDirectory(mrb_state* mrb, mrb_value self) { +char * parameter_dir; + +mrb_get_args(mrb, "z", ¶meter_dir); +bool return_of_ChangeDirectory; + +return_of_ChangeDirectory = ChangeDirectory(parameter_dir); +return mrb_bool_value(return_of_ChangeDirectory); +} + +//bool CheckCollisionBoxSphere +static mrb_value +mrb_CheckCollisionBoxSphere(mrb_state* mrb, mrb_value self) { +BoundingBox *parameter_box; +Vector3 *parameter_center; +float parameter_radius; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "box"), +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_box = DATA_GET_PTR(mrb, kw_values[0], &mrb_BoundingBox_struct, BoundingBox); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +bool return_of_CheckCollisionBoxSphere; + +return_of_CheckCollisionBoxSphere = CheckCollisionBoxSphere(*parameter_box, *parameter_center, parameter_radius); +return mrb_bool_value(return_of_CheckCollisionBoxSphere); +} + +//bool CheckCollisionBoxes +static mrb_value +mrb_CheckCollisionBoxes(mrb_state* mrb, mrb_value self) { +BoundingBox *parameter_box1; +BoundingBox *parameter_box2; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "box1"), +mrb_intern_lit(mrb, "box2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_box1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_BoundingBox_struct, BoundingBox); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_box2 = DATA_GET_PTR(mrb, kw_values[1], &mrb_BoundingBox_struct, BoundingBox); + +} + +bool return_of_CheckCollisionBoxes; + +return_of_CheckCollisionBoxes = CheckCollisionBoxes(*parameter_box1, *parameter_box2); +return mrb_bool_value(return_of_CheckCollisionBoxes); +} + +//bool CheckCollisionCircleRec +static mrb_value +mrb_CheckCollisionCircleRec(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +float parameter_radius; +Rectangle *parameter_rec; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rec") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[2], &mrb_Rectangle_struct, Rectangle); + +} + +bool return_of_CheckCollisionCircleRec; + +return_of_CheckCollisionCircleRec = CheckCollisionCircleRec(*parameter_center, parameter_radius, *parameter_rec); +return mrb_bool_value(return_of_CheckCollisionCircleRec); +} + +//bool CheckCollisionCircles +static mrb_value +mrb_CheckCollisionCircles(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center1; +float parameter_radius1; +Vector2 *parameter_center2; +float parameter_radius2; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center1"), +mrb_intern_lit(mrb, "radius1"), +mrb_intern_lit(mrb, "center2"), +mrb_intern_lit(mrb, "radius2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius1 = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius2 = mrb_as_float(mrb, kw_values[3]); +} + +bool return_of_CheckCollisionCircles; + +return_of_CheckCollisionCircles = CheckCollisionCircles(*parameter_center1, parameter_radius1, *parameter_center2, parameter_radius2); +return mrb_bool_value(return_of_CheckCollisionCircles); +} + +//bool CheckCollisionLines +static mrb_value +mrb_CheckCollisionLines(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_startPos1; +Vector2 *parameter_endPos1; +Vector2 *parameter_startPos2; +Vector2 *parameter_endPos2; +Vector2 *parameter_collisionPoint; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos1"), +mrb_intern_lit(mrb, "endPos1"), +mrb_intern_lit(mrb, "startPos2"), +mrb_intern_lit(mrb, "endPos2"), +mrb_intern_lit(mrb, "collisionPoint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos1 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos2 = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_collisionPoint = DATA_GET_PTR(mrb, kw_values[4], &mrb_Vector2_struct, Vector2); + +} + +bool return_of_CheckCollisionLines; + +return_of_CheckCollisionLines = CheckCollisionLines(*parameter_startPos1, *parameter_endPos1, *parameter_startPos2, *parameter_endPos2, parameter_collisionPoint); +return mrb_bool_value(return_of_CheckCollisionLines); +} + +//bool CheckCollisionPointCircle +static mrb_value +mrb_CheckCollisionPointCircle(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_point; +Vector2 *parameter_center; +float parameter_radius; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "point"), +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_point = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +bool return_of_CheckCollisionPointCircle; + +return_of_CheckCollisionPointCircle = CheckCollisionPointCircle(*parameter_point, *parameter_center, parameter_radius); +return mrb_bool_value(return_of_CheckCollisionPointCircle); +} + +//bool CheckCollisionPointLine +static mrb_value +mrb_CheckCollisionPointLine(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_point; +Vector2 *parameter_p1; +Vector2 *parameter_p2; +int parameter_threshold; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "point"), +mrb_intern_lit(mrb, "p1"), +mrb_intern_lit(mrb, "p2"), +mrb_intern_lit(mrb, "threshold") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_point = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p1 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_threshold = mrb_as_int(mrb, kw_values[3]); +} + +bool return_of_CheckCollisionPointLine; + +return_of_CheckCollisionPointLine = CheckCollisionPointLine(*parameter_point, *parameter_p1, *parameter_p2, parameter_threshold); +return mrb_bool_value(return_of_CheckCollisionPointLine); +} + +//bool CheckCollisionPointRec +static mrb_value +mrb_CheckCollisionPointRec(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_point; +Rectangle *parameter_rec; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "point"), +mrb_intern_lit(mrb, "rec") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_point = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +bool return_of_CheckCollisionPointRec; + +return_of_CheckCollisionPointRec = CheckCollisionPointRec(*parameter_point, *parameter_rec); +return mrb_bool_value(return_of_CheckCollisionPointRec); +} + +//bool CheckCollisionPointTriangle +static mrb_value +mrb_CheckCollisionPointTriangle(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_point; +Vector2 *parameter_p1; +Vector2 *parameter_p2; +Vector2 *parameter_p3; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "point"), +mrb_intern_lit(mrb, "p1"), +mrb_intern_lit(mrb, "p2"), +mrb_intern_lit(mrb, "p3") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_point = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p1 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p3 = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +bool return_of_CheckCollisionPointTriangle; + +return_of_CheckCollisionPointTriangle = CheckCollisionPointTriangle(*parameter_point, *parameter_p1, *parameter_p2, *parameter_p3); +return mrb_bool_value(return_of_CheckCollisionPointTriangle); +} + +//bool CheckCollisionRecs +static mrb_value +mrb_CheckCollisionRecs(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec1; +Rectangle *parameter_rec2; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec1"), +mrb_intern_lit(mrb, "rec2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec2 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +bool return_of_CheckCollisionRecs; + +return_of_CheckCollisionRecs = CheckCollisionRecs(*parameter_rec1, *parameter_rec2); +return mrb_bool_value(return_of_CheckCollisionRecs); +} + +//bool CheckCollisionSpheres +static mrb_value +mrb_CheckCollisionSpheres(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_center1; +float parameter_radius1; +Vector3 *parameter_center2; +float parameter_radius2; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center1"), +mrb_intern_lit(mrb, "radius1"), +mrb_intern_lit(mrb, "center2"), +mrb_intern_lit(mrb, "radius2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius1 = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius2 = mrb_as_float(mrb, kw_values[3]); +} + +bool return_of_CheckCollisionSpheres; + +return_of_CheckCollisionSpheres = CheckCollisionSpheres(*parameter_center1, parameter_radius1, *parameter_center2, parameter_radius2); +return mrb_bool_value(return_of_CheckCollisionSpheres); +} + +//void ClearBackground +static mrb_value +mrb_ClearBackground(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_color; + +mrb_get_args(mrb, "o", ¶meter_mrb_color); +Color *parameter_color; +parameter_color = DATA_GET_PTR(mrb, parameter_mrb_color, &mrb_Color_struct, Color); + +ClearBackground(*parameter_color); +return mrb_nil_value(); +} + +//void ClearDirectoryFiles +static mrb_value +mrb_ClearDirectoryFiles(mrb_state* mrb, mrb_value self) { + +ClearDirectoryFiles(); +return mrb_nil_value(); +} + +//void ClearDroppedFiles +static mrb_value +mrb_ClearDroppedFiles(mrb_state* mrb, mrb_value self) { + +ClearDroppedFiles(); +return mrb_nil_value(); +} + +//void ClearWindowState +static mrb_value +mrb_ClearWindowState(mrb_state* mrb, mrb_value self) { +mrb_int parameter_flags; + +mrb_get_args(mrb, "i", ¶meter_flags); + +ClearWindowState(parameter_flags); +return mrb_nil_value(); +} + +//void CloseAudioDevice +static mrb_value +mrb_CloseAudioDevice(mrb_state* mrb, mrb_value self) { + +CloseAudioDevice(); +return mrb_nil_value(); +} + +//void CloseWindow +static mrb_value +mrb_CloseWindow(mrb_state* mrb, mrb_value self) { + +CloseWindow(); +return mrb_nil_value(); +} + +//const char * CodepointToUTF8 +static mrb_value +mrb_CodepointToUTF8(mrb_state* mrb, mrb_value self) { +int parameter_codepoint; +int parameter_byteSize; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "codepoint"), +mrb_intern_lit(mrb, "byteSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_codepoint = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_byteSize = mrb_as_int(mrb, kw_values[1]); +} + +const char * return_of_CodepointToUTF8; + +return_of_CodepointToUTF8 = CodepointToUTF8(parameter_codepoint, (int *)¶meter_byteSize); +return mrb_str_new_cstr(mrb, return_of_CodepointToUTF8); +} + +//Color ColorAlpha +static mrb_value +mrb_ColorAlpha(mrb_state* mrb, mrb_value self) { +Color *parameter_color; +float parameter_alpha; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "color"), +mrb_intern_lit(mrb, "alpha") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[0], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_alpha = mrb_as_float(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_ColorAlpha = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_ColorAlpha = ColorAlpha(*parameter_color, parameter_alpha); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_ColorAlpha)); +} + +//Color ColorAlphaBlend +static mrb_value +mrb_ColorAlphaBlend(mrb_state* mrb, mrb_value self) { +Color *parameter_dst; +Color *parameter_src; +Color *parameter_tint; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "src"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_src = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_ColorAlphaBlend = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_ColorAlphaBlend = ColorAlphaBlend(*parameter_dst, *parameter_src, *parameter_tint); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_ColorAlphaBlend)); +} + +//Color ColorFromHSV +static mrb_value +mrb_ColorFromHSV(mrb_state* mrb, mrb_value self) { +float parameter_hue; +float parameter_saturation; +float parameter_value; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "hue"), +mrb_intern_lit(mrb, "saturation"), +mrb_intern_lit(mrb, "value") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_hue = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_saturation = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_value = mrb_as_float(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_ColorFromHSV = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_ColorFromHSV = ColorFromHSV(parameter_hue, parameter_saturation, parameter_value); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_ColorFromHSV)); +} + +//Color ColorFromNormalized +static mrb_value +mrb_ColorFromNormalized(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_normalized; + +mrb_get_args(mrb, "o", ¶meter_mrb_normalized); +Vector4 *parameter_normalized; +parameter_normalized = DATA_GET_PTR(mrb, parameter_mrb_normalized, &mrb_Vector4_struct, Vector4); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_ColorFromNormalized = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_ColorFromNormalized = ColorFromNormalized(*parameter_normalized); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_ColorFromNormalized)); +} + +//Vector4 ColorNormalize +static mrb_value +mrb_ColorNormalize(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_color; + +mrb_get_args(mrb, "o", ¶meter_mrb_color); +Color *parameter_color; +parameter_color = DATA_GET_PTR(mrb, parameter_mrb_color, &mrb_Color_struct, Color); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector4_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector4_struct.struct_name); +Vector4 *return_of_ColorNormalize = (Vector4 *)mrb_malloc(mrb, sizeof(Vector4)); + +*return_of_ColorNormalize = ColorNormalize(*parameter_color); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector4_mrb_class, &mrb_Vector4_struct, return_of_ColorNormalize)); +} + +//Vector3 ColorToHSV +static mrb_value +mrb_ColorToHSV(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_color; + +mrb_get_args(mrb, "o", ¶meter_mrb_color); +Color *parameter_color; +parameter_color = DATA_GET_PTR(mrb, parameter_mrb_color, &mrb_Color_struct, Color); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector3_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector3_struct.struct_name); +Vector3 *return_of_ColorToHSV = (Vector3 *)mrb_malloc(mrb, sizeof(Vector3)); + +*return_of_ColorToHSV = ColorToHSV(*parameter_color); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector3_mrb_class, &mrb_Vector3_struct, return_of_ColorToHSV)); +} + +//int ColorToInt +static mrb_value +mrb_ColorToInt(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_color; + +mrb_get_args(mrb, "o", ¶meter_mrb_color); +Color *parameter_color; +parameter_color = DATA_GET_PTR(mrb, parameter_mrb_color, &mrb_Color_struct, Color); +int return_of_ColorToInt; + +return_of_ColorToInt = ColorToInt(*parameter_color); +return mrb_fixnum_value(return_of_ColorToInt); +} + +//bool DirectoryExists +static mrb_value +mrb_DirectoryExists(mrb_state* mrb, mrb_value self) { +char * parameter_dirPath; + +mrb_get_args(mrb, "z", ¶meter_dirPath); +bool return_of_DirectoryExists; + +return_of_DirectoryExists = DirectoryExists(parameter_dirPath); +return mrb_bool_value(return_of_DirectoryExists); +} + +//void DisableCursor +static mrb_value +mrb_DisableCursor(mrb_state* mrb, mrb_value self) { + +DisableCursor(); +return mrb_nil_value(); +} + +//void DrawBoundingBox +static mrb_value +mrb_DrawBoundingBox(mrb_state* mrb, mrb_value self) { +BoundingBox *parameter_box; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "box"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_box = DATA_GET_PTR(mrb, kw_values[0], &mrb_BoundingBox_struct, BoundingBox); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +DrawBoundingBox(*parameter_box, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCircle +static mrb_value +mrb_DrawCircle(mrb_state* mrb, mrb_value self) { +int parameter_centerX; +int parameter_centerY; +float parameter_radius; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerX"), +mrb_intern_lit(mrb, "centerY"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawCircle(parameter_centerX, parameter_centerY, parameter_radius, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCircle3D +static mrb_value +mrb_DrawCircle3D(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_center; +float parameter_radius; +Vector3 *parameter_rotationAxis; +float parameter_rotationAngle; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rotationAxis"), +mrb_intern_lit(mrb, "rotationAngle"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotationAxis = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotationAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawCircle3D(*parameter_center, parameter_radius, *parameter_rotationAxis, parameter_rotationAngle, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCircleGradient +static mrb_value +mrb_DrawCircleGradient(mrb_state* mrb, mrb_value self) { +int parameter_centerX; +int parameter_centerY; +float parameter_radius; +Color *parameter_color1; +Color *parameter_color2; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerX"), +mrb_intern_lit(mrb, "centerY"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color1"), +mrb_intern_lit(mrb, "color2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color1 = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color2 = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawCircleGradient(parameter_centerX, parameter_centerY, parameter_radius, *parameter_color1, *parameter_color2); +return mrb_nil_value(); +} + +//void DrawCircleLines +static mrb_value +mrb_DrawCircleLines(mrb_state* mrb, mrb_value self) { +int parameter_centerX; +int parameter_centerY; +float parameter_radius; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerX"), +mrb_intern_lit(mrb, "centerY"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawCircleLines(parameter_centerX, parameter_centerY, parameter_radius, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCircleSector +static mrb_value +mrb_DrawCircleSector(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +float parameter_radius; +float parameter_startAngle; +float parameter_endAngle; +int parameter_segments; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "startAngle"), +mrb_intern_lit(mrb, "endAngle"), +mrb_intern_lit(mrb, "segments"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startAngle = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_segments = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCircleSector(*parameter_center, parameter_radius, parameter_startAngle, parameter_endAngle, parameter_segments, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCircleSectorLines +static mrb_value +mrb_DrawCircleSectorLines(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +float parameter_radius; +float parameter_startAngle; +float parameter_endAngle; +int parameter_segments; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "startAngle"), +mrb_intern_lit(mrb, "endAngle"), +mrb_intern_lit(mrb, "segments"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startAngle = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_segments = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCircleSectorLines(*parameter_center, parameter_radius, parameter_startAngle, parameter_endAngle, parameter_segments, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCircleV +static mrb_value +mrb_DrawCircleV(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +float parameter_radius; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawCircleV(*parameter_center, parameter_radius, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCube +static mrb_value +mrb_DrawCube(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +float parameter_width; +float parameter_height; +float parameter_length; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "length"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawCube(*parameter_position, parameter_width, parameter_height, parameter_length, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCubeTexture +static mrb_value +mrb_DrawCubeTexture(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Vector3 *parameter_position; +float parameter_width; +float parameter_height; +float parameter_length; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "length"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCubeTexture(*parameter_texture, *parameter_position, parameter_width, parameter_height, parameter_length, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCubeTextureRec +static mrb_value +mrb_DrawCubeTextureRec(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Rectangle *parameter_source; +Vector3 *parameter_position; +float parameter_width; +float parameter_height; +float parameter_length; +Color *parameter_color; + +uint32_t kw_num = 7; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "source"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "length"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_source = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_float(mrb, kw_values[5]); +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[6], &mrb_Color_struct, Color); + +} + + +DrawCubeTextureRec(*parameter_texture, *parameter_source, *parameter_position, parameter_width, parameter_height, parameter_length, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCubeV +static mrb_value +mrb_DrawCubeV(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +Vector3 *parameter_size; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawCubeV(*parameter_position, *parameter_size, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCubeWires +static mrb_value +mrb_DrawCubeWires(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +float parameter_width; +float parameter_height; +float parameter_length; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "length"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawCubeWires(*parameter_position, parameter_width, parameter_height, parameter_length, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCubeWiresV +static mrb_value +mrb_DrawCubeWiresV(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +Vector3 *parameter_size; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawCubeWiresV(*parameter_position, *parameter_size, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCylinder +static mrb_value +mrb_DrawCylinder(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +float parameter_radiusTop; +float parameter_radiusBottom; +float parameter_height; +int parameter_slices; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "radiusTop"), +mrb_intern_lit(mrb, "radiusBottom"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "slices"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusTop = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusBottom = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCylinder(*parameter_position, parameter_radiusTop, parameter_radiusBottom, parameter_height, parameter_slices, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCylinderEx +static mrb_value +mrb_DrawCylinderEx(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_startPos; +Vector3 *parameter_endPos; +float parameter_startRadius; +float parameter_endRadius; +int parameter_sides; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "startRadius"), +mrb_intern_lit(mrb, "endRadius"), +mrb_intern_lit(mrb, "sides"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startRadius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endRadius = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCylinderEx(*parameter_startPos, *parameter_endPos, parameter_startRadius, parameter_endRadius, parameter_sides, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCylinderWires +static mrb_value +mrb_DrawCylinderWires(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +float parameter_radiusTop; +float parameter_radiusBottom; +float parameter_height; +int parameter_slices; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "radiusTop"), +mrb_intern_lit(mrb, "radiusBottom"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "slices"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusTop = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusBottom = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCylinderWires(*parameter_position, parameter_radiusTop, parameter_radiusBottom, parameter_height, parameter_slices, *parameter_color); +return mrb_nil_value(); +} + +//void DrawCylinderWiresEx +static mrb_value +mrb_DrawCylinderWiresEx(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_startPos; +Vector3 *parameter_endPos; +float parameter_startRadius; +float parameter_endRadius; +int parameter_sides; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "startRadius"), +mrb_intern_lit(mrb, "endRadius"), +mrb_intern_lit(mrb, "sides"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startRadius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endRadius = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawCylinderWiresEx(*parameter_startPos, *parameter_endPos, parameter_startRadius, parameter_endRadius, parameter_sides, *parameter_color); +return mrb_nil_value(); +} + +//void DrawEllipse +static mrb_value +mrb_DrawEllipse(mrb_state* mrb, mrb_value self) { +int parameter_centerX; +int parameter_centerY; +float parameter_radiusH; +float parameter_radiusV; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerX"), +mrb_intern_lit(mrb, "centerY"), +mrb_intern_lit(mrb, "radiusH"), +mrb_intern_lit(mrb, "radiusV"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusH = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusV = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawEllipse(parameter_centerX, parameter_centerY, parameter_radiusH, parameter_radiusV, *parameter_color); +return mrb_nil_value(); +} + +//void DrawEllipseLines +static mrb_value +mrb_DrawEllipseLines(mrb_state* mrb, mrb_value self) { +int parameter_centerX; +int parameter_centerY; +float parameter_radiusH; +float parameter_radiusV; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerX"), +mrb_intern_lit(mrb, "centerY"), +mrb_intern_lit(mrb, "radiusH"), +mrb_intern_lit(mrb, "radiusV"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusH = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radiusV = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawEllipseLines(parameter_centerX, parameter_centerY, parameter_radiusH, parameter_radiusV, *parameter_color); +return mrb_nil_value(); +} + +//void DrawFPS +static mrb_value +mrb_DrawFPS(mrb_state* mrb, mrb_value self) { +int parameter_posX; +int parameter_posY; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[1]); +} + + +DrawFPS(parameter_posX, parameter_posY); +return mrb_nil_value(); +} + +//void DrawGrid +static mrb_value +mrb_DrawGrid(mrb_state* mrb, mrb_value self) { +int parameter_slices; +float parameter_spacing; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "slices"), +mrb_intern_lit(mrb, "spacing") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_spacing = mrb_as_float(mrb, kw_values[1]); +} + + +DrawGrid(parameter_slices, parameter_spacing); +return mrb_nil_value(); +} + +//void DrawLine +static mrb_value +mrb_DrawLine(mrb_state* mrb, mrb_value self) { +int parameter_startPosX; +int parameter_startPosY; +int parameter_endPosX; +int parameter_endPosY; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPosX"), +mrb_intern_lit(mrb, "startPosY"), +mrb_intern_lit(mrb, "endPosX"), +mrb_intern_lit(mrb, "endPosY"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPosX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPosY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPosX = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPosY = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawLine(parameter_startPosX, parameter_startPosY, parameter_endPosX, parameter_endPosY, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLine3D +static mrb_value +mrb_DrawLine3D(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_startPos; +Vector3 *parameter_endPos; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawLine3D(*parameter_startPos, *parameter_endPos, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLineBezier +static mrb_value +mrb_DrawLineBezier(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_startPos; +Vector2 *parameter_endPos; +float parameter_thick; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "thick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_thick = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawLineBezier(*parameter_startPos, *parameter_endPos, parameter_thick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLineBezierCubic +static mrb_value +mrb_DrawLineBezierCubic(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_startPos; +Vector2 *parameter_endPos; +Vector2 *parameter_startControlPos; +Vector2 *parameter_endControlPos; +float parameter_thick; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "startControlPos"), +mrb_intern_lit(mrb, "endControlPos"), +mrb_intern_lit(mrb, "thick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startControlPos = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endControlPos = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_thick = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawLineBezierCubic(*parameter_startPos, *parameter_endPos, *parameter_startControlPos, *parameter_endControlPos, parameter_thick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLineBezierQuad +static mrb_value +mrb_DrawLineBezierQuad(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_startPos; +Vector2 *parameter_endPos; +Vector2 *parameter_controlPos; +float parameter_thick; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "controlPos"), +mrb_intern_lit(mrb, "thick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_controlPos = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_thick = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawLineBezierQuad(*parameter_startPos, *parameter_endPos, *parameter_controlPos, parameter_thick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLineEx +static mrb_value +mrb_DrawLineEx(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_startPos; +Vector2 *parameter_endPos; +float parameter_thick; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "thick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_thick = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawLineEx(*parameter_startPos, *parameter_endPos, parameter_thick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLineStrip +static mrb_value +mrb_DrawLineStrip(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_points; +int parameter_pointCount; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "points"), +mrb_intern_lit(mrb, "pointCount"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_points = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pointCount = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawLineStrip(parameter_points, parameter_pointCount, *parameter_color); +return mrb_nil_value(); +} + +//void DrawLineV +static mrb_value +mrb_DrawLineV(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_startPos; +Vector2 *parameter_endPos; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "startPos"), +mrb_intern_lit(mrb, "endPos"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPos = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawLineV(*parameter_startPos, *parameter_endPos, *parameter_color); +return mrb_nil_value(); +} + +//void DrawMesh +static mrb_value +mrb_DrawMesh(mrb_state* mrb, mrb_value self) { +Mesh *parameter_mesh; +Material *parameter_material; +Matrix *parameter_transform; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "mesh"), +mrb_intern_lit(mrb, "material"), +mrb_intern_lit(mrb, "transform") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_mesh = DATA_GET_PTR(mrb, kw_values[0], &mrb_Mesh_struct, Mesh); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_material = DATA_GET_PTR(mrb, kw_values[1], &mrb_Material_struct, Material); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_transform = DATA_GET_PTR(mrb, kw_values[2], &mrb_Matrix_struct, Matrix); + +} + + +DrawMesh(*parameter_mesh, *parameter_material, *parameter_transform); +return mrb_nil_value(); +} + +//void DrawModel +static mrb_value +mrb_DrawModel(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +Vector3 *parameter_position; +float parameter_scale; +Color *parameter_tint; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scale = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawModel(*parameter_model, *parameter_position, parameter_scale, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawModelEx +static mrb_value +mrb_DrawModelEx(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +Vector3 *parameter_position; +Vector3 *parameter_rotationAxis; +float parameter_rotationAngle; +Vector3 *parameter_scale; +Color *parameter_tint; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "rotationAxis"), +mrb_intern_lit(mrb, "rotationAngle"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotationAxis = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotationAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scale = DATA_GET_PTR(mrb, kw_values[4], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawModelEx(*parameter_model, *parameter_position, *parameter_rotationAxis, parameter_rotationAngle, *parameter_scale, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawModelWires +static mrb_value +mrb_DrawModelWires(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +Vector3 *parameter_position; +float parameter_scale; +Color *parameter_tint; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scale = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawModelWires(*parameter_model, *parameter_position, parameter_scale, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawModelWiresEx +static mrb_value +mrb_DrawModelWiresEx(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +Vector3 *parameter_position; +Vector3 *parameter_rotationAxis; +float parameter_rotationAngle; +Vector3 *parameter_scale; +Color *parameter_tint; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "rotationAxis"), +mrb_intern_lit(mrb, "rotationAngle"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotationAxis = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotationAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scale = DATA_GET_PTR(mrb, kw_values[4], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawModelWiresEx(*parameter_model, *parameter_position, *parameter_rotationAxis, parameter_rotationAngle, *parameter_scale, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawPixel +static mrb_value +mrb_DrawPixel(mrb_state* mrb, mrb_value self) { +int parameter_posX; +int parameter_posY; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawPixel(parameter_posX, parameter_posY, *parameter_color); +return mrb_nil_value(); +} + +//void DrawPixelV +static mrb_value +mrb_DrawPixelV(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_position; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +DrawPixelV(*parameter_position, *parameter_color); +return mrb_nil_value(); +} + +//void DrawPlane +static mrb_value +mrb_DrawPlane(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_centerPos; +Vector2 *parameter_size; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerPos"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawPlane(*parameter_centerPos, *parameter_size, *parameter_color); +return mrb_nil_value(); +} + +//void DrawPoint3D +static mrb_value +mrb_DrawPoint3D(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_position; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +DrawPoint3D(*parameter_position, *parameter_color); +return mrb_nil_value(); +} + +//void DrawPoly +static mrb_value +mrb_DrawPoly(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +int parameter_sides; +float parameter_radius; +float parameter_rotation; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "sides"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawPoly(*parameter_center, parameter_sides, parameter_radius, parameter_rotation, *parameter_color); +return mrb_nil_value(); +} + +//void DrawPolyLines +static mrb_value +mrb_DrawPolyLines(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +int parameter_sides; +float parameter_radius; +float parameter_rotation; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "sides"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawPolyLines(*parameter_center, parameter_sides, parameter_radius, parameter_rotation, *parameter_color); +return mrb_nil_value(); +} + +//void DrawPolyLinesEx +static mrb_value +mrb_DrawPolyLinesEx(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +int parameter_sides; +float parameter_radius; +float parameter_rotation; +float parameter_lineThick; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "sides"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "lineThick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_lineThick = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawPolyLinesEx(*parameter_center, parameter_sides, parameter_radius, parameter_rotation, parameter_lineThick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRay +static mrb_value +mrb_DrawRay(mrb_state* mrb, mrb_value self) { +Ray *parameter_ray; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ray"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ray = DATA_GET_PTR(mrb, kw_values[0], &mrb_Ray_struct, Ray); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +DrawRay(*parameter_ray, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangle +static mrb_value +mrb_DrawRectangle(mrb_state* mrb, mrb_value self) { +int parameter_posX; +int parameter_posY; +int parameter_width; +int parameter_height; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawRectangle(parameter_posX, parameter_posY, parameter_width, parameter_height, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangleGradientEx +static mrb_value +mrb_DrawRectangleGradientEx(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec; +Color *parameter_col1; +Color *parameter_col2; +Color *parameter_col3; +Color *parameter_col4; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "col1"), +mrb_intern_lit(mrb, "col2"), +mrb_intern_lit(mrb, "col3"), +mrb_intern_lit(mrb, "col4") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_col1 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_col2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_col3 = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_col4 = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawRectangleGradientEx(*parameter_rec, *parameter_col1, *parameter_col2, *parameter_col3, *parameter_col4); +return mrb_nil_value(); +} + +//void DrawRectangleGradientH +static mrb_value +mrb_DrawRectangleGradientH(mrb_state* mrb, mrb_value self) { +int parameter_posX; +int parameter_posY; +int parameter_width; +int parameter_height; +Color *parameter_color1; +Color *parameter_color2; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "color1"), +mrb_intern_lit(mrb, "color2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color1 = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color2 = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawRectangleGradientH(parameter_posX, parameter_posY, parameter_width, parameter_height, *parameter_color1, *parameter_color2); +return mrb_nil_value(); +} + +//void DrawRectangleGradientV +static mrb_value +mrb_DrawRectangleGradientV(mrb_state* mrb, mrb_value self) { +int parameter_posX; +int parameter_posY; +int parameter_width; +int parameter_height; +Color *parameter_color1; +Color *parameter_color2; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "color1"), +mrb_intern_lit(mrb, "color2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color1 = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color2 = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawRectangleGradientV(parameter_posX, parameter_posY, parameter_width, parameter_height, *parameter_color1, *parameter_color2); +return mrb_nil_value(); +} + +//void DrawRectangleLines +static mrb_value +mrb_DrawRectangleLines(mrb_state* mrb, mrb_value self) { +int parameter_posX; +int parameter_posY; +int parameter_width; +int parameter_height; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawRectangleLines(parameter_posX, parameter_posY, parameter_width, parameter_height, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangleLinesEx +static mrb_value +mrb_DrawRectangleLinesEx(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec; +float parameter_lineThick; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "lineThick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_lineThick = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawRectangleLinesEx(*parameter_rec, parameter_lineThick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectanglePro +static mrb_value +mrb_DrawRectanglePro(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec; +Vector2 *parameter_origin; +float parameter_rotation; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "origin"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_origin = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawRectanglePro(*parameter_rec, *parameter_origin, parameter_rotation, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangleRec +static mrb_value +mrb_DrawRectangleRec(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +DrawRectangleRec(*parameter_rec, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangleRounded +static mrb_value +mrb_DrawRectangleRounded(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec; +float parameter_roundness; +int parameter_segments; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "roundness"), +mrb_intern_lit(mrb, "segments"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_roundness = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_segments = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawRectangleRounded(*parameter_rec, parameter_roundness, parameter_segments, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangleRoundedLines +static mrb_value +mrb_DrawRectangleRoundedLines(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec; +float parameter_roundness; +int parameter_segments; +float parameter_lineThick; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "roundness"), +mrb_intern_lit(mrb, "segments"), +mrb_intern_lit(mrb, "lineThick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_roundness = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_segments = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_lineThick = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawRectangleRoundedLines(*parameter_rec, parameter_roundness, parameter_segments, parameter_lineThick, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRectangleV +static mrb_value +mrb_DrawRectangleV(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_position; +Vector2 *parameter_size; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawRectangleV(*parameter_position, *parameter_size, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRing +static mrb_value +mrb_DrawRing(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +float parameter_innerRadius; +float parameter_outerRadius; +float parameter_startAngle; +float parameter_endAngle; +int parameter_segments; +Color *parameter_color; + +uint32_t kw_num = 7; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "innerRadius"), +mrb_intern_lit(mrb, "outerRadius"), +mrb_intern_lit(mrb, "startAngle"), +mrb_intern_lit(mrb, "endAngle"), +mrb_intern_lit(mrb, "segments"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_innerRadius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_outerRadius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endAngle = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_segments = mrb_as_int(mrb, kw_values[5]); +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[6], &mrb_Color_struct, Color); + +} + + +DrawRing(*parameter_center, parameter_innerRadius, parameter_outerRadius, parameter_startAngle, parameter_endAngle, parameter_segments, *parameter_color); +return mrb_nil_value(); +} + +//void DrawRingLines +static mrb_value +mrb_DrawRingLines(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_center; +float parameter_innerRadius; +float parameter_outerRadius; +float parameter_startAngle; +float parameter_endAngle; +int parameter_segments; +Color *parameter_color; + +uint32_t kw_num = 7; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "innerRadius"), +mrb_intern_lit(mrb, "outerRadius"), +mrb_intern_lit(mrb, "startAngle"), +mrb_intern_lit(mrb, "endAngle"), +mrb_intern_lit(mrb, "segments"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_innerRadius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_outerRadius = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startAngle = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endAngle = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_segments = mrb_as_int(mrb, kw_values[5]); +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[6], &mrb_Color_struct, Color); + +} + + +DrawRingLines(*parameter_center, parameter_innerRadius, parameter_outerRadius, parameter_startAngle, parameter_endAngle, parameter_segments, *parameter_color); +return mrb_nil_value(); +} + +//void DrawSphere +static mrb_value +mrb_DrawSphere(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_centerPos; +float parameter_radius; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerPos"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawSphere(*parameter_centerPos, parameter_radius, *parameter_color); +return mrb_nil_value(); +} + +//void DrawSphereEx +static mrb_value +mrb_DrawSphereEx(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_centerPos; +float parameter_radius; +int parameter_rings; +int parameter_slices; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerPos"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rings"), +mrb_intern_lit(mrb, "slices"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rings = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawSphereEx(*parameter_centerPos, parameter_radius, parameter_rings, parameter_slices, *parameter_color); +return mrb_nil_value(); +} + +//void DrawSphereWires +static mrb_value +mrb_DrawSphereWires(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_centerPos; +float parameter_radius; +int parameter_rings; +int parameter_slices; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "centerPos"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rings"), +mrb_intern_lit(mrb, "slices"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerPos = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rings = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawSphereWires(*parameter_centerPos, parameter_radius, parameter_rings, parameter_slices, *parameter_color); +return mrb_nil_value(); +} + +//void DrawText +static mrb_value +mrb_DrawText(mrb_state* mrb, mrb_value self) { +char * parameter_text; +int parameter_posX; +int parameter_posY; +int parameter_fontSize; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawText(parameter_text, parameter_posX, parameter_posY, parameter_fontSize, *parameter_color); +return mrb_nil_value(); +} + +//void DrawTextCodepoint +static mrb_value +mrb_DrawTextCodepoint(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +int parameter_codepoint; +Vector2 *parameter_position; +float parameter_fontSize; +Color *parameter_tint; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "codepoint"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_codepoint = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawTextCodepoint(*parameter_font, parameter_codepoint, *parameter_position, parameter_fontSize, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextEx +static mrb_value +mrb_DrawTextEx(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +char * parameter_text; +Vector2 *parameter_position; +float parameter_fontSize; +float parameter_spacing; +Color *parameter_tint; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "spacing"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_spacing = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawTextEx(*parameter_font, parameter_text, *parameter_position, parameter_fontSize, parameter_spacing, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextPro +static mrb_value +mrb_DrawTextPro(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +char * parameter_text; +Vector2 *parameter_position; +Vector2 *parameter_origin; +float parameter_rotation; +float parameter_fontSize; +float parameter_spacing; +Color *parameter_tint; + +uint32_t kw_num = 8; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "origin"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "spacing"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_origin = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_float(mrb, kw_values[5]); +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_spacing = mrb_as_float(mrb, kw_values[6]); +} + +if (mrb_undef_p(kw_values[7])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[7], &mrb_Color_struct, Color); + +} + + +DrawTextPro(*parameter_font, parameter_text, *parameter_position, *parameter_origin, parameter_rotation, parameter_fontSize, parameter_spacing, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTexture +static mrb_value +mrb_DrawTexture(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +int parameter_posX; +int parameter_posY; +Color *parameter_tint; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawTexture(*parameter_texture, parameter_posX, parameter_posY, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextureEx +static mrb_value +mrb_DrawTextureEx(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Vector2 *parameter_position; +float parameter_rotation; +float parameter_scale; +Color *parameter_tint; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scale = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawTextureEx(*parameter_texture, *parameter_position, parameter_rotation, parameter_scale, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextureNPatch +static mrb_value +mrb_DrawTextureNPatch(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +NPatchInfo *parameter_nPatchInfo; +Rectangle *parameter_dest; +Vector2 *parameter_origin; +float parameter_rotation; +Color *parameter_tint; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "nPatchInfo"), +mrb_intern_lit(mrb, "dest"), +mrb_intern_lit(mrb, "origin"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_nPatchInfo = DATA_GET_PTR(mrb, kw_values[1], &mrb_NPatchInfo_struct, NPatchInfo); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dest = DATA_GET_PTR(mrb, kw_values[2], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_origin = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawTextureNPatch(*parameter_texture, *parameter_nPatchInfo, *parameter_dest, *parameter_origin, parameter_rotation, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTexturePoly +static mrb_value +mrb_DrawTexturePoly(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Vector2 *parameter_center; +Vector2 *parameter_points; +Vector2 *parameter_texcoords; +int parameter_pointCount; +Color *parameter_tint; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "points"), +mrb_intern_lit(mrb, "texcoords"), +mrb_intern_lit(mrb, "pointCount"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_points = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texcoords = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pointCount = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawTexturePoly(*parameter_texture, *parameter_center, parameter_points, parameter_texcoords, parameter_pointCount, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTexturePro +static mrb_value +mrb_DrawTexturePro(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Rectangle *parameter_source; +Rectangle *parameter_dest; +Vector2 *parameter_origin; +float parameter_rotation; +Color *parameter_tint; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "source"), +mrb_intern_lit(mrb, "dest"), +mrb_intern_lit(mrb, "origin"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_source = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dest = DATA_GET_PTR(mrb, kw_values[2], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_origin = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +DrawTexturePro(*parameter_texture, *parameter_source, *parameter_dest, *parameter_origin, parameter_rotation, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextureQuad +static mrb_value +mrb_DrawTextureQuad(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Vector2 *parameter_tiling; +Vector2 *parameter_offset; +Rectangle *parameter_quad; +Color *parameter_tint; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "tiling"), +mrb_intern_lit(mrb, "offset"), +mrb_intern_lit(mrb, "quad"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tiling = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_offset = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_quad = DATA_GET_PTR(mrb, kw_values[3], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +DrawTextureQuad(*parameter_texture, *parameter_tiling, *parameter_offset, *parameter_quad, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextureRec +static mrb_value +mrb_DrawTextureRec(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Rectangle *parameter_source; +Vector2 *parameter_position; +Color *parameter_tint; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "source"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_source = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawTextureRec(*parameter_texture, *parameter_source, *parameter_position, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextureTiled +static mrb_value +mrb_DrawTextureTiled(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Rectangle *parameter_source; +Rectangle *parameter_dest; +Vector2 *parameter_origin; +float parameter_rotation; +float parameter_scale; +Color *parameter_tint; + +uint32_t kw_num = 7; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "source"), +mrb_intern_lit(mrb, "dest"), +mrb_intern_lit(mrb, "origin"), +mrb_intern_lit(mrb, "rotation"), +mrb_intern_lit(mrb, "scale"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_source = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dest = DATA_GET_PTR(mrb, kw_values[2], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_origin = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rotation = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scale = mrb_as_float(mrb, kw_values[5]); +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[6], &mrb_Color_struct, Color); + +} + + +DrawTextureTiled(*parameter_texture, *parameter_source, *parameter_dest, *parameter_origin, parameter_rotation, parameter_scale, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTextureV +static mrb_value +mrb_DrawTextureV(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Vector2 *parameter_position; +Color *parameter_tint; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawTextureV(*parameter_texture, *parameter_position, *parameter_tint); +return mrb_nil_value(); +} + +//void DrawTriangle +static mrb_value +mrb_DrawTriangle(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_v1; +Vector2 *parameter_v2; +Vector2 *parameter_v3; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "v1"), +mrb_intern_lit(mrb, "v2"), +mrb_intern_lit(mrb, "v3"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v2 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v3 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawTriangle(*parameter_v1, *parameter_v2, *parameter_v3, *parameter_color); +return mrb_nil_value(); +} + +//void DrawTriangle3D +static mrb_value +mrb_DrawTriangle3D(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_v1; +Vector3 *parameter_v2; +Vector3 *parameter_v3; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "v1"), +mrb_intern_lit(mrb, "v2"), +mrb_intern_lit(mrb, "v3"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v2 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v3 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawTriangle3D(*parameter_v1, *parameter_v2, *parameter_v3, *parameter_color); +return mrb_nil_value(); +} + +//void DrawTriangleFan +static mrb_value +mrb_DrawTriangleFan(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_points; +int parameter_pointCount; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "points"), +mrb_intern_lit(mrb, "pointCount"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_points = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pointCount = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawTriangleFan(parameter_points, parameter_pointCount, *parameter_color); +return mrb_nil_value(); +} + +//void DrawTriangleLines +static mrb_value +mrb_DrawTriangleLines(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_v1; +Vector2 *parameter_v2; +Vector2 *parameter_v3; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "v1"), +mrb_intern_lit(mrb, "v2"), +mrb_intern_lit(mrb, "v3"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v2 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_v3 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +DrawTriangleLines(*parameter_v1, *parameter_v2, *parameter_v3, *parameter_color); +return mrb_nil_value(); +} + +//void DrawTriangleStrip +static mrb_value +mrb_DrawTriangleStrip(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_points; +int parameter_pointCount; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "points"), +mrb_intern_lit(mrb, "pointCount"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_points = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pointCount = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawTriangleStrip(parameter_points, parameter_pointCount, *parameter_color); +return mrb_nil_value(); +} + +//void DrawTriangleStrip3D +static mrb_value +mrb_DrawTriangleStrip3D(mrb_state* mrb, mrb_value self) { +Vector3 *parameter_points; +int parameter_pointCount; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "points"), +mrb_intern_lit(mrb, "pointCount"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_points = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pointCount = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +DrawTriangleStrip3D(parameter_points, parameter_pointCount, *parameter_color); +return mrb_nil_value(); +} + +//void EnableCursor +static mrb_value +mrb_EnableCursor(mrb_state* mrb, mrb_value self) { + +EnableCursor(); +return mrb_nil_value(); +} + +//void EndBlendMode +static mrb_value +mrb_EndBlendMode(mrb_state* mrb, mrb_value self) { + +EndBlendMode(); +return mrb_nil_value(); +} + +//void EndDrawing +static mrb_value +mrb_EndDrawing(mrb_state* mrb, mrb_value self) { + +EndDrawing(); +return mrb_nil_value(); +} + +//void EndMode2D +static mrb_value +mrb_EndMode2D(mrb_state* mrb, mrb_value self) { + +EndMode2D(); +return mrb_nil_value(); +} + +//void EndMode3D +static mrb_value +mrb_EndMode3D(mrb_state* mrb, mrb_value self) { + +EndMode3D(); +return mrb_nil_value(); +} + +//void EndScissorMode +static mrb_value +mrb_EndScissorMode(mrb_state* mrb, mrb_value self) { + +EndScissorMode(); +return mrb_nil_value(); +} + +//void EndShaderMode +static mrb_value +mrb_EndShaderMode(mrb_state* mrb, mrb_value self) { + +EndShaderMode(); +return mrb_nil_value(); +} + +//void EndTextureMode +static mrb_value +mrb_EndTextureMode(mrb_state* mrb, mrb_value self) { + +EndTextureMode(); +return mrb_nil_value(); +} + +//void EndVrStereoMode +static mrb_value +mrb_EndVrStereoMode(mrb_state* mrb, mrb_value self) { + +EndVrStereoMode(); +return mrb_nil_value(); +} + +//bool ExportFontAsCode +static mrb_value +mrb_ExportFontAsCode(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +char * parameter_fileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "fileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_ExportFontAsCode; + +return_of_ExportFontAsCode = ExportFontAsCode(*parameter_font, parameter_fileName); +return mrb_bool_value(return_of_ExportFontAsCode); +} + +//bool ExportImage +static mrb_value +mrb_ExportImage(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +char * parameter_fileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "fileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_ExportImage; + +return_of_ExportImage = ExportImage(*parameter_image, parameter_fileName); +return mrb_bool_value(return_of_ExportImage); +} + +//bool ExportImageAsCode +static mrb_value +mrb_ExportImageAsCode(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +char * parameter_fileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "fileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_ExportImageAsCode; + +return_of_ExportImageAsCode = ExportImageAsCode(*parameter_image, parameter_fileName); +return mrb_bool_value(return_of_ExportImageAsCode); +} + +//bool ExportMesh +static mrb_value +mrb_ExportMesh(mrb_state* mrb, mrb_value self) { +Mesh *parameter_mesh; +char * parameter_fileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "mesh"), +mrb_intern_lit(mrb, "fileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_mesh = DATA_GET_PTR(mrb, kw_values[0], &mrb_Mesh_struct, Mesh); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_ExportMesh; + +return_of_ExportMesh = ExportMesh(*parameter_mesh, parameter_fileName); +return mrb_bool_value(return_of_ExportMesh); +} + +//bool ExportWave +static mrb_value +mrb_ExportWave(mrb_state* mrb, mrb_value self) { +Wave *parameter_wave; +char * parameter_fileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "wave"), +mrb_intern_lit(mrb, "fileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_wave = DATA_GET_PTR(mrb, kw_values[0], &mrb_Wave_struct, Wave); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_ExportWave; + +return_of_ExportWave = ExportWave(*parameter_wave, parameter_fileName); +return mrb_bool_value(return_of_ExportWave); +} + +//bool ExportWaveAsCode +static mrb_value +mrb_ExportWaveAsCode(mrb_state* mrb, mrb_value self) { +Wave *parameter_wave; +char * parameter_fileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "wave"), +mrb_intern_lit(mrb, "fileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_wave = DATA_GET_PTR(mrb, kw_values[0], &mrb_Wave_struct, Wave); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_ExportWaveAsCode; + +return_of_ExportWaveAsCode = ExportWaveAsCode(*parameter_wave, parameter_fileName); +return mrb_bool_value(return_of_ExportWaveAsCode); +} + +//Color Fade +static mrb_value +mrb_Fade(mrb_state* mrb, mrb_value self) { +Color *parameter_color; +float parameter_alpha; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "color"), +mrb_intern_lit(mrb, "alpha") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[0], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_alpha = mrb_as_float(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_Fade = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_Fade = Fade(*parameter_color, parameter_alpha); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_Fade)); +} + +//bool FileExists +static mrb_value +mrb_FileExists(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +bool return_of_FileExists; + +return_of_FileExists = FileExists(parameter_fileName); +return mrb_bool_value(return_of_FileExists); +} + +//Image GenImageCellular +static mrb_value +mrb_GenImageCellular(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +int parameter_tileSize; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "tileSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tileSize = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageCellular = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageCellular = GenImageCellular(parameter_width, parameter_height, parameter_tileSize); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageCellular)); +} + +//Image GenImageChecked +static mrb_value +mrb_GenImageChecked(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +int parameter_checksX; +int parameter_checksY; +Color *parameter_col1; +Color *parameter_col2; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "checksX"), +mrb_intern_lit(mrb, "checksY"), +mrb_intern_lit(mrb, "col1"), +mrb_intern_lit(mrb, "col2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_checksX = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_checksY = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_col1 = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_col2 = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageChecked = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageChecked = GenImageChecked(parameter_width, parameter_height, parameter_checksX, parameter_checksY, *parameter_col1, *parameter_col2); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageChecked)); +} + +//Image GenImageColor +static mrb_value +mrb_GenImageColor(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageColor = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageColor = GenImageColor(parameter_width, parameter_height, *parameter_color); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageColor)); +} + +//Image GenImageGradientH +static mrb_value +mrb_GenImageGradientH(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +Color *parameter_left; +Color *parameter_right; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "left"), +mrb_intern_lit(mrb, "right") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_left = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_right = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageGradientH = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageGradientH = GenImageGradientH(parameter_width, parameter_height, *parameter_left, *parameter_right); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageGradientH)); +} + +//Image GenImageGradientRadial +static mrb_value +mrb_GenImageGradientRadial(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +float parameter_density; +Color *parameter_inner; +Color *parameter_outer; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "density"), +mrb_intern_lit(mrb, "inner"), +mrb_intern_lit(mrb, "outer") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_density = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_inner = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_outer = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageGradientRadial = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageGradientRadial = GenImageGradientRadial(parameter_width, parameter_height, parameter_density, *parameter_inner, *parameter_outer); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageGradientRadial)); +} + +//Image GenImageGradientV +static mrb_value +mrb_GenImageGradientV(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +Color *parameter_top; +Color *parameter_bottom; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "top"), +mrb_intern_lit(mrb, "bottom") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_top = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_bottom = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageGradientV = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageGradientV = GenImageGradientV(parameter_width, parameter_height, *parameter_top, *parameter_bottom); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageGradientV)); +} + +//Image GenImageWhiteNoise +static mrb_value +mrb_GenImageWhiteNoise(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +float parameter_factor; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "factor") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_factor = mrb_as_float(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_GenImageWhiteNoise = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_GenImageWhiteNoise = GenImageWhiteNoise(parameter_width, parameter_height, parameter_factor); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_GenImageWhiteNoise)); +} + +//void GenMeshBinormals +static mrb_value +mrb_GenMeshBinormals(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_mesh; + +mrb_get_args(mrb, "o", ¶meter_mrb_mesh); +Mesh *parameter_mesh; +parameter_mesh = DATA_GET_PTR(mrb, parameter_mrb_mesh, &mrb_Mesh_struct, Mesh); + +GenMeshBinormals(parameter_mesh); +return mrb_nil_value(); +} + +//Mesh GenMeshCone +static mrb_value +mrb_GenMeshCone(mrb_state* mrb, mrb_value self) { +float parameter_radius; +float parameter_height; +int parameter_slices; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "slices") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshCone = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshCone = GenMeshCone(parameter_radius, parameter_height, parameter_slices); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshCone)); +} + +//Mesh GenMeshCube +static mrb_value +mrb_GenMeshCube(mrb_state* mrb, mrb_value self) { +float parameter_width; +float parameter_height; +float parameter_length; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "length") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_float(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshCube = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshCube = GenMeshCube(parameter_width, parameter_height, parameter_length); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshCube)); +} + +//Mesh GenMeshCubicmap +static mrb_value +mrb_GenMeshCubicmap(mrb_state* mrb, mrb_value self) { +Image *parameter_cubicmap; +Vector3 *parameter_cubeSize; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "cubicmap"), +mrb_intern_lit(mrb, "cubeSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_cubicmap = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_cubeSize = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshCubicmap = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshCubicmap = GenMeshCubicmap(*parameter_cubicmap, *parameter_cubeSize); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshCubicmap)); +} + +//Mesh GenMeshCylinder +static mrb_value +mrb_GenMeshCylinder(mrb_state* mrb, mrb_value self) { +float parameter_radius; +float parameter_height; +int parameter_slices; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "slices") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshCylinder = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshCylinder = GenMeshCylinder(parameter_radius, parameter_height, parameter_slices); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshCylinder)); +} + +//Mesh GenMeshHeightmap +static mrb_value +mrb_GenMeshHeightmap(mrb_state* mrb, mrb_value self) { +Image *parameter_heightmap; +Vector3 *parameter_size; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "heightmap"), +mrb_intern_lit(mrb, "size") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_heightmap = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshHeightmap = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshHeightmap = GenMeshHeightmap(*parameter_heightmap, *parameter_size); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshHeightmap)); +} + +//Mesh GenMeshHemiSphere +static mrb_value +mrb_GenMeshHemiSphere(mrb_state* mrb, mrb_value self) { +float parameter_radius; +int parameter_rings; +int parameter_slices; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rings"), +mrb_intern_lit(mrb, "slices") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rings = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshHemiSphere = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshHemiSphere = GenMeshHemiSphere(parameter_radius, parameter_rings, parameter_slices); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshHemiSphere)); +} + +//Mesh GenMeshKnot +static mrb_value +mrb_GenMeshKnot(mrb_state* mrb, mrb_value self) { +float parameter_radius; +float parameter_size; +int parameter_radSeg; +int parameter_sides; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "radSeg"), +mrb_intern_lit(mrb, "sides") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radSeg = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[3]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshKnot = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshKnot = GenMeshKnot(parameter_radius, parameter_size, parameter_radSeg, parameter_sides); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshKnot)); +} + +//Mesh GenMeshPlane +static mrb_value +mrb_GenMeshPlane(mrb_state* mrb, mrb_value self) { +float parameter_width; +float parameter_length; +int parameter_resX; +int parameter_resZ; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "length"), +mrb_intern_lit(mrb, "resX"), +mrb_intern_lit(mrb, "resZ") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_resX = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_resZ = mrb_as_int(mrb, kw_values[3]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshPlane = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshPlane = GenMeshPlane(parameter_width, parameter_length, parameter_resX, parameter_resZ); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshPlane)); +} + +//Mesh GenMeshPoly +static mrb_value +mrb_GenMeshPoly(mrb_state* mrb, mrb_value self) { +int parameter_sides; +float parameter_radius; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "sides"), +mrb_intern_lit(mrb, "radius") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshPoly = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshPoly = GenMeshPoly(parameter_sides, parameter_radius); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshPoly)); +} + +//Mesh GenMeshSphere +static mrb_value +mrb_GenMeshSphere(mrb_state* mrb, mrb_value self) { +float parameter_radius; +int parameter_rings; +int parameter_slices; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "rings"), +mrb_intern_lit(mrb, "slices") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rings = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_slices = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshSphere = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshSphere = GenMeshSphere(parameter_radius, parameter_rings, parameter_slices); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshSphere)); +} + +//void GenMeshTangents +static mrb_value +mrb_GenMeshTangents(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_mesh; + +mrb_get_args(mrb, "o", ¶meter_mrb_mesh); +Mesh *parameter_mesh; +parameter_mesh = DATA_GET_PTR(mrb, parameter_mrb_mesh, &mrb_Mesh_struct, Mesh); + +GenMeshTangents(parameter_mesh); +return mrb_nil_value(); +} + +//Mesh GenMeshTorus +static mrb_value +mrb_GenMeshTorus(mrb_state* mrb, mrb_value self) { +float parameter_radius; +float parameter_size; +int parameter_radSeg; +int parameter_sides; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "radSeg"), +mrb_intern_lit(mrb, "sides") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = mrb_as_float(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radSeg = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sides = mrb_as_int(mrb, kw_values[3]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *mesh_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Mesh_struct.struct_name); +Mesh *return_of_GenMeshTorus = (Mesh *)mrb_malloc(mrb, sizeof(Mesh)); + +*return_of_GenMeshTorus = GenMeshTorus(parameter_radius, parameter_size, parameter_radSeg, parameter_sides); +return mrb_obj_value(Data_Wrap_Struct(mrb, mesh_mrb_class, &mrb_Mesh_struct, return_of_GenMeshTorus)); +} + +//const char * GetApplicationDirectory +static mrb_value +mrb_GetApplicationDirectory(mrb_state* mrb, mrb_value self) { +const char * return_of_GetApplicationDirectory; + +return_of_GetApplicationDirectory = GetApplicationDirectory(); +return mrb_str_new_cstr(mrb, return_of_GetApplicationDirectory); +} + +//Matrix GetCameraMatrix2D +static mrb_value +mrb_GetCameraMatrix2D(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_camera; + +mrb_get_args(mrb, "o", ¶meter_mrb_camera); +Camera2D *parameter_camera; +parameter_camera = DATA_GET_PTR(mrb, parameter_mrb_camera, &mrb_Camera2D_struct, Camera2D); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *matrix_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Matrix_struct.struct_name); +Matrix *return_of_GetCameraMatrix2D = (Matrix *)mrb_malloc(mrb, sizeof(Matrix)); + +*return_of_GetCameraMatrix2D = GetCameraMatrix2D(*parameter_camera); +return mrb_obj_value(Data_Wrap_Struct(mrb, matrix_mrb_class, &mrb_Matrix_struct, return_of_GetCameraMatrix2D)); +} + +//int GetCharPressed +static mrb_value +mrb_GetCharPressed(mrb_state* mrb, mrb_value self) { +int return_of_GetCharPressed; + +return_of_GetCharPressed = GetCharPressed(); +return mrb_fixnum_value(return_of_GetCharPressed); +} + +//const char * GetClipboardText +static mrb_value +mrb_GetClipboardText(mrb_state* mrb, mrb_value self) { +const char * return_of_GetClipboardText; + +return_of_GetClipboardText = GetClipboardText(); +return mrb_str_new_cstr(mrb, return_of_GetClipboardText); +} + +//int GetCodepoint +static mrb_value +mrb_GetCodepoint(mrb_state* mrb, mrb_value self) { +char * parameter_text; +int parameter_bytesProcessed; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "bytesProcessed") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_bytesProcessed = mrb_as_int(mrb, kw_values[1]); +} + +int return_of_GetCodepoint; + +return_of_GetCodepoint = GetCodepoint(parameter_text, (int *)¶meter_bytesProcessed); +return mrb_fixnum_value(return_of_GetCodepoint); +} + +//int GetCodepointCount +static mrb_value +mrb_GetCodepointCount(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); +int return_of_GetCodepointCount; + +return_of_GetCodepointCount = GetCodepointCount(parameter_text); +return mrb_fixnum_value(return_of_GetCodepointCount); +} + +//Rectangle GetCollisionRec +static mrb_value +mrb_GetCollisionRec(mrb_state* mrb, mrb_value self) { +Rectangle *parameter_rec1; +Rectangle *parameter_rec2; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "rec1"), +mrb_intern_lit(mrb, "rec2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec1 = DATA_GET_PTR(mrb, kw_values[0], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec2 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *rectangle_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Rectangle_struct.struct_name); +Rectangle *return_of_GetCollisionRec = (Rectangle *)mrb_malloc(mrb, sizeof(Rectangle)); + +*return_of_GetCollisionRec = GetCollisionRec(*parameter_rec1, *parameter_rec2); +return mrb_obj_value(Data_Wrap_Struct(mrb, rectangle_mrb_class, &mrb_Rectangle_struct, return_of_GetCollisionRec)); +} + +//Color GetColor +static mrb_value +mrb_GetColor(mrb_state* mrb, mrb_value self) { +mrb_int parameter_hexValue; + +mrb_get_args(mrb, "i", ¶meter_hexValue); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_GetColor = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_GetColor = GetColor(parameter_hexValue); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_GetColor)); +} + +//int GetCurrentMonitor +static mrb_value +mrb_GetCurrentMonitor(mrb_state* mrb, mrb_value self) { +int return_of_GetCurrentMonitor; + +return_of_GetCurrentMonitor = GetCurrentMonitor(); +return mrb_fixnum_value(return_of_GetCurrentMonitor); +} + +//const char * GetDirectoryPath +static mrb_value +mrb_GetDirectoryPath(mrb_state* mrb, mrb_value self) { +char * parameter_filePath; + +mrb_get_args(mrb, "z", ¶meter_filePath); +const char * return_of_GetDirectoryPath; + +return_of_GetDirectoryPath = GetDirectoryPath(parameter_filePath); +return mrb_str_new_cstr(mrb, return_of_GetDirectoryPath); +} + +//int GetFPS +static mrb_value +mrb_GetFPS(mrb_state* mrb, mrb_value self) { +int return_of_GetFPS; + +return_of_GetFPS = GetFPS(); +return mrb_fixnum_value(return_of_GetFPS); +} + +//const char * GetFileExtension +static mrb_value +mrb_GetFileExtension(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +const char * return_of_GetFileExtension; + +return_of_GetFileExtension = GetFileExtension(parameter_fileName); +return mrb_str_new_cstr(mrb, return_of_GetFileExtension); +} + +//int GetFileLength +static mrb_value +mrb_GetFileLength(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +int return_of_GetFileLength; + +return_of_GetFileLength = GetFileLength(parameter_fileName); +return mrb_fixnum_value(return_of_GetFileLength); +} + +//long GetFileModTime +static mrb_value +mrb_GetFileModTime(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +long return_of_GetFileModTime; + +return_of_GetFileModTime = GetFileModTime(parameter_fileName); +return mrb_fixnum_value(return_of_GetFileModTime); +} + +//const char * GetFileName +static mrb_value +mrb_GetFileName(mrb_state* mrb, mrb_value self) { +char * parameter_filePath; + +mrb_get_args(mrb, "z", ¶meter_filePath); +const char * return_of_GetFileName; + +return_of_GetFileName = GetFileName(parameter_filePath); +return mrb_str_new_cstr(mrb, return_of_GetFileName); +} + +//const char * GetFileNameWithoutExt +static mrb_value +mrb_GetFileNameWithoutExt(mrb_state* mrb, mrb_value self) { +char * parameter_filePath; + +mrb_get_args(mrb, "z", ¶meter_filePath); +const char * return_of_GetFileNameWithoutExt; + +return_of_GetFileNameWithoutExt = GetFileNameWithoutExt(parameter_filePath); +return mrb_str_new_cstr(mrb, return_of_GetFileNameWithoutExt); +} + +//Font GetFontDefault +static mrb_value +mrb_GetFontDefault(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *font_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Font_struct.struct_name); +Font *return_of_GetFontDefault = (Font *)mrb_malloc(mrb, sizeof(Font)); + +*return_of_GetFontDefault = GetFontDefault(); +return mrb_obj_value(Data_Wrap_Struct(mrb, font_mrb_class, &mrb_Font_struct, return_of_GetFontDefault)); +} + +//float GetFrameTime +static mrb_value +mrb_GetFrameTime(mrb_state* mrb, mrb_value self) { +float return_of_GetFrameTime; + +return_of_GetFrameTime = GetFrameTime(); +return mrb_float_value(mrb, return_of_GetFrameTime); +} + +//int GetGamepadAxisCount +static mrb_value +mrb_GetGamepadAxisCount(mrb_state* mrb, mrb_value self) { +mrb_int parameter_gamepad; + +mrb_get_args(mrb, "i", ¶meter_gamepad); +int return_of_GetGamepadAxisCount; + +return_of_GetGamepadAxisCount = GetGamepadAxisCount(parameter_gamepad); +return mrb_fixnum_value(return_of_GetGamepadAxisCount); +} + +//float GetGamepadAxisMovement +static mrb_value +mrb_GetGamepadAxisMovement(mrb_state* mrb, mrb_value self) { +int parameter_gamepad; +int parameter_axis; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "gamepad"), +mrb_intern_lit(mrb, "axis") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_gamepad = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_axis = mrb_as_int(mrb, kw_values[1]); +} + +float return_of_GetGamepadAxisMovement; + +return_of_GetGamepadAxisMovement = GetGamepadAxisMovement(parameter_gamepad, parameter_axis); +return mrb_float_value(mrb, return_of_GetGamepadAxisMovement); +} + +//int GetGamepadButtonPressed +static mrb_value +mrb_GetGamepadButtonPressed(mrb_state* mrb, mrb_value self) { +int return_of_GetGamepadButtonPressed; + +return_of_GetGamepadButtonPressed = GetGamepadButtonPressed(); +return mrb_fixnum_value(return_of_GetGamepadButtonPressed); +} + +//const char * GetGamepadName +static mrb_value +mrb_GetGamepadName(mrb_state* mrb, mrb_value self) { +mrb_int parameter_gamepad; + +mrb_get_args(mrb, "i", ¶meter_gamepad); +const char * return_of_GetGamepadName; + +return_of_GetGamepadName = GetGamepadName(parameter_gamepad); +return mrb_str_new_cstr(mrb, return_of_GetGamepadName); +} + +//int GetGestureDetected +static mrb_value +mrb_GetGestureDetected(mrb_state* mrb, mrb_value self) { +int return_of_GetGestureDetected; + +return_of_GetGestureDetected = GetGestureDetected(); +return mrb_fixnum_value(return_of_GetGestureDetected); +} + +//float GetGestureDragAngle +static mrb_value +mrb_GetGestureDragAngle(mrb_state* mrb, mrb_value self) { +float return_of_GetGestureDragAngle; + +return_of_GetGestureDragAngle = GetGestureDragAngle(); +return mrb_float_value(mrb, return_of_GetGestureDragAngle); +} + +//Vector2 GetGestureDragVector +static mrb_value +mrb_GetGestureDragVector(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetGestureDragVector = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetGestureDragVector = GetGestureDragVector(); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetGestureDragVector)); +} + +//float GetGestureHoldDuration +static mrb_value +mrb_GetGestureHoldDuration(mrb_state* mrb, mrb_value self) { +float return_of_GetGestureHoldDuration; + +return_of_GetGestureHoldDuration = GetGestureHoldDuration(); +return mrb_float_value(mrb, return_of_GetGestureHoldDuration); +} + +//float GetGesturePinchAngle +static mrb_value +mrb_GetGesturePinchAngle(mrb_state* mrb, mrb_value self) { +float return_of_GetGesturePinchAngle; + +return_of_GetGesturePinchAngle = GetGesturePinchAngle(); +return mrb_float_value(mrb, return_of_GetGesturePinchAngle); +} + +//Vector2 GetGesturePinchVector +static mrb_value +mrb_GetGesturePinchVector(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetGesturePinchVector = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetGesturePinchVector = GetGesturePinchVector(); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetGesturePinchVector)); +} + +//Rectangle GetGlyphAtlasRec +static mrb_value +mrb_GetGlyphAtlasRec(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +int parameter_codepoint; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "codepoint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_codepoint = mrb_as_int(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *rectangle_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Rectangle_struct.struct_name); +Rectangle *return_of_GetGlyphAtlasRec = (Rectangle *)mrb_malloc(mrb, sizeof(Rectangle)); + +*return_of_GetGlyphAtlasRec = GetGlyphAtlasRec(*parameter_font, parameter_codepoint); +return mrb_obj_value(Data_Wrap_Struct(mrb, rectangle_mrb_class, &mrb_Rectangle_struct, return_of_GetGlyphAtlasRec)); +} + +//int GetGlyphIndex +static mrb_value +mrb_GetGlyphIndex(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +int parameter_codepoint; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "codepoint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_codepoint = mrb_as_int(mrb, kw_values[1]); +} + +int return_of_GetGlyphIndex; + +return_of_GetGlyphIndex = GetGlyphIndex(*parameter_font, parameter_codepoint); +return mrb_fixnum_value(return_of_GetGlyphIndex); +} + +//GlyphInfo GetGlyphInfo +static mrb_value +mrb_GetGlyphInfo(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +int parameter_codepoint; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "codepoint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_codepoint = mrb_as_int(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *glyphinfo_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_GlyphInfo_struct.struct_name); +GlyphInfo *return_of_GetGlyphInfo = (GlyphInfo *)mrb_malloc(mrb, sizeof(GlyphInfo)); + +*return_of_GetGlyphInfo = GetGlyphInfo(*parameter_font, parameter_codepoint); +return mrb_obj_value(Data_Wrap_Struct(mrb, glyphinfo_mrb_class, &mrb_GlyphInfo_struct, return_of_GetGlyphInfo)); +} + +//Rectangle GetImageAlphaBorder +static mrb_value +mrb_GetImageAlphaBorder(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +float parameter_threshold; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "threshold") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_threshold = mrb_as_float(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *rectangle_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Rectangle_struct.struct_name); +Rectangle *return_of_GetImageAlphaBorder = (Rectangle *)mrb_malloc(mrb, sizeof(Rectangle)); + +*return_of_GetImageAlphaBorder = GetImageAlphaBorder(*parameter_image, parameter_threshold); +return mrb_obj_value(Data_Wrap_Struct(mrb, rectangle_mrb_class, &mrb_Rectangle_struct, return_of_GetImageAlphaBorder)); +} + +//Color GetImageColor +static mrb_value +mrb_GetImageColor(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_x; +int parameter_y; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_x = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_y = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_GetImageColor = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_GetImageColor = GetImageColor(*parameter_image, parameter_x, parameter_y); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_GetImageColor)); +} + +//int GetKeyPressed +static mrb_value +mrb_GetKeyPressed(mrb_state* mrb, mrb_value self) { +int return_of_GetKeyPressed; + +return_of_GetKeyPressed = GetKeyPressed(); +return mrb_fixnum_value(return_of_GetKeyPressed); +} + +//BoundingBox GetMeshBoundingBox +static mrb_value +mrb_GetMeshBoundingBox(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_mesh; + +mrb_get_args(mrb, "o", ¶meter_mrb_mesh); +Mesh *parameter_mesh; +parameter_mesh = DATA_GET_PTR(mrb, parameter_mrb_mesh, &mrb_Mesh_struct, Mesh); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *boundingbox_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_BoundingBox_struct.struct_name); +BoundingBox *return_of_GetMeshBoundingBox = (BoundingBox *)mrb_malloc(mrb, sizeof(BoundingBox)); + +*return_of_GetMeshBoundingBox = GetMeshBoundingBox(*parameter_mesh); +return mrb_obj_value(Data_Wrap_Struct(mrb, boundingbox_mrb_class, &mrb_BoundingBox_struct, return_of_GetMeshBoundingBox)); +} + +//BoundingBox GetModelBoundingBox +static mrb_value +mrb_GetModelBoundingBox(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_model; + +mrb_get_args(mrb, "o", ¶meter_mrb_model); +Model *parameter_model; +parameter_model = DATA_GET_PTR(mrb, parameter_mrb_model, &mrb_Model_struct, Model); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *boundingbox_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_BoundingBox_struct.struct_name); +BoundingBox *return_of_GetModelBoundingBox = (BoundingBox *)mrb_malloc(mrb, sizeof(BoundingBox)); + +*return_of_GetModelBoundingBox = GetModelBoundingBox(*parameter_model); +return mrb_obj_value(Data_Wrap_Struct(mrb, boundingbox_mrb_class, &mrb_BoundingBox_struct, return_of_GetModelBoundingBox)); +} + +//int GetMonitorCount +static mrb_value +mrb_GetMonitorCount(mrb_state* mrb, mrb_value self) { +int return_of_GetMonitorCount; + +return_of_GetMonitorCount = GetMonitorCount(); +return mrb_fixnum_value(return_of_GetMonitorCount); +} + +//int GetMonitorHeight +static mrb_value +mrb_GetMonitorHeight(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +int return_of_GetMonitorHeight; + +return_of_GetMonitorHeight = GetMonitorHeight(parameter_monitor); +return mrb_fixnum_value(return_of_GetMonitorHeight); +} + +//const char * GetMonitorName +static mrb_value +mrb_GetMonitorName(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +const char * return_of_GetMonitorName; + +return_of_GetMonitorName = GetMonitorName(parameter_monitor); +return mrb_str_new_cstr(mrb, return_of_GetMonitorName); +} + +//int GetMonitorPhysicalHeight +static mrb_value +mrb_GetMonitorPhysicalHeight(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +int return_of_GetMonitorPhysicalHeight; + +return_of_GetMonitorPhysicalHeight = GetMonitorPhysicalHeight(parameter_monitor); +return mrb_fixnum_value(return_of_GetMonitorPhysicalHeight); +} + +//int GetMonitorPhysicalWidth +static mrb_value +mrb_GetMonitorPhysicalWidth(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +int return_of_GetMonitorPhysicalWidth; + +return_of_GetMonitorPhysicalWidth = GetMonitorPhysicalWidth(parameter_monitor); +return mrb_fixnum_value(return_of_GetMonitorPhysicalWidth); +} + +//Vector2 GetMonitorPosition +static mrb_value +mrb_GetMonitorPosition(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetMonitorPosition = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetMonitorPosition = GetMonitorPosition(parameter_monitor); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetMonitorPosition)); +} + +//int GetMonitorRefreshRate +static mrb_value +mrb_GetMonitorRefreshRate(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +int return_of_GetMonitorRefreshRate; + +return_of_GetMonitorRefreshRate = GetMonitorRefreshRate(parameter_monitor); +return mrb_fixnum_value(return_of_GetMonitorRefreshRate); +} + +//int GetMonitorWidth +static mrb_value +mrb_GetMonitorWidth(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); +int return_of_GetMonitorWidth; + +return_of_GetMonitorWidth = GetMonitorWidth(parameter_monitor); +return mrb_fixnum_value(return_of_GetMonitorWidth); +} + +//Vector2 GetMouseDelta +static mrb_value +mrb_GetMouseDelta(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetMouseDelta = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetMouseDelta = GetMouseDelta(); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetMouseDelta)); +} + +//Vector2 GetMousePosition +static mrb_value +mrb_GetMousePosition(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetMousePosition = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetMousePosition = GetMousePosition(); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetMousePosition)); +} + +//float GetMouseWheelMove +static mrb_value +mrb_GetMouseWheelMove(mrb_state* mrb, mrb_value self) { +float return_of_GetMouseWheelMove; + +return_of_GetMouseWheelMove = GetMouseWheelMove(); +return mrb_float_value(mrb, return_of_GetMouseWheelMove); +} + +//int GetMouseX +static mrb_value +mrb_GetMouseX(mrb_state* mrb, mrb_value self) { +int return_of_GetMouseX; + +return_of_GetMouseX = GetMouseX(); +return mrb_fixnum_value(return_of_GetMouseX); +} + +//int GetMouseY +static mrb_value +mrb_GetMouseY(mrb_state* mrb, mrb_value self) { +int return_of_GetMouseY; + +return_of_GetMouseY = GetMouseY(); +return mrb_fixnum_value(return_of_GetMouseY); +} + +//float GetMusicTimeLength +static mrb_value +mrb_GetMusicTimeLength(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); +float return_of_GetMusicTimeLength; + +return_of_GetMusicTimeLength = GetMusicTimeLength(*parameter_music); +return mrb_float_value(mrb, return_of_GetMusicTimeLength); +} + +//float GetMusicTimePlayed +static mrb_value +mrb_GetMusicTimePlayed(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); +float return_of_GetMusicTimePlayed; + +return_of_GetMusicTimePlayed = GetMusicTimePlayed(*parameter_music); +return mrb_float_value(mrb, return_of_GetMusicTimePlayed); +} + +//int GetPixelDataSize +static mrb_value +mrb_GetPixelDataSize(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +int parameter_format; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "format") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_format = mrb_as_int(mrb, kw_values[2]); +} + +int return_of_GetPixelDataSize; + +return_of_GetPixelDataSize = GetPixelDataSize(parameter_width, parameter_height, parameter_format); +return mrb_fixnum_value(return_of_GetPixelDataSize); +} + +//const char * GetPrevDirectoryPath +static mrb_value +mrb_GetPrevDirectoryPath(mrb_state* mrb, mrb_value self) { +char * parameter_dirPath; + +mrb_get_args(mrb, "z", ¶meter_dirPath); +const char * return_of_GetPrevDirectoryPath; + +return_of_GetPrevDirectoryPath = GetPrevDirectoryPath(parameter_dirPath); +return mrb_str_new_cstr(mrb, return_of_GetPrevDirectoryPath); +} + +//int GetRandomValue +static mrb_value +mrb_GetRandomValue(mrb_state* mrb, mrb_value self) { +int parameter_min; +int parameter_max; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "min"), +mrb_intern_lit(mrb, "max") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_min = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_max = mrb_as_int(mrb, kw_values[1]); +} + +int return_of_GetRandomValue; + +return_of_GetRandomValue = GetRandomValue(parameter_min, parameter_max); +return mrb_fixnum_value(return_of_GetRandomValue); +} + +//RayCollision GetRayCollisionBox +static mrb_value +mrb_GetRayCollisionBox(mrb_state* mrb, mrb_value self) { +Ray *parameter_ray; +BoundingBox *parameter_box; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ray"), +mrb_intern_lit(mrb, "box") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ray = DATA_GET_PTR(mrb, kw_values[0], &mrb_Ray_struct, Ray); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_box = DATA_GET_PTR(mrb, kw_values[1], &mrb_BoundingBox_struct, BoundingBox); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *raycollision_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RayCollision_struct.struct_name); +RayCollision *return_of_GetRayCollisionBox = (RayCollision *)mrb_malloc(mrb, sizeof(RayCollision)); + +*return_of_GetRayCollisionBox = GetRayCollisionBox(*parameter_ray, *parameter_box); +return mrb_obj_value(Data_Wrap_Struct(mrb, raycollision_mrb_class, &mrb_RayCollision_struct, return_of_GetRayCollisionBox)); +} + +//RayCollision GetRayCollisionMesh +static mrb_value +mrb_GetRayCollisionMesh(mrb_state* mrb, mrb_value self) { +Ray *parameter_ray; +Mesh *parameter_mesh; +Matrix *parameter_transform; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ray"), +mrb_intern_lit(mrb, "mesh"), +mrb_intern_lit(mrb, "transform") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ray = DATA_GET_PTR(mrb, kw_values[0], &mrb_Ray_struct, Ray); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_mesh = DATA_GET_PTR(mrb, kw_values[1], &mrb_Mesh_struct, Mesh); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_transform = DATA_GET_PTR(mrb, kw_values[2], &mrb_Matrix_struct, Matrix); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *raycollision_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RayCollision_struct.struct_name); +RayCollision *return_of_GetRayCollisionMesh = (RayCollision *)mrb_malloc(mrb, sizeof(RayCollision)); + +*return_of_GetRayCollisionMesh = GetRayCollisionMesh(*parameter_ray, *parameter_mesh, *parameter_transform); +return mrb_obj_value(Data_Wrap_Struct(mrb, raycollision_mrb_class, &mrb_RayCollision_struct, return_of_GetRayCollisionMesh)); +} + +//RayCollision GetRayCollisionQuad +static mrb_value +mrb_GetRayCollisionQuad(mrb_state* mrb, mrb_value self) { +Ray *parameter_ray; +Vector3 *parameter_p1; +Vector3 *parameter_p2; +Vector3 *parameter_p3; +Vector3 *parameter_p4; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ray"), +mrb_intern_lit(mrb, "p1"), +mrb_intern_lit(mrb, "p2"), +mrb_intern_lit(mrb, "p3"), +mrb_intern_lit(mrb, "p4") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ray = DATA_GET_PTR(mrb, kw_values[0], &mrb_Ray_struct, Ray); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p1 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p3 = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p4 = DATA_GET_PTR(mrb, kw_values[4], &mrb_Vector3_struct, Vector3); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *raycollision_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RayCollision_struct.struct_name); +RayCollision *return_of_GetRayCollisionQuad = (RayCollision *)mrb_malloc(mrb, sizeof(RayCollision)); + +*return_of_GetRayCollisionQuad = GetRayCollisionQuad(*parameter_ray, *parameter_p1, *parameter_p2, *parameter_p3, *parameter_p4); +return mrb_obj_value(Data_Wrap_Struct(mrb, raycollision_mrb_class, &mrb_RayCollision_struct, return_of_GetRayCollisionQuad)); +} + +//RayCollision GetRayCollisionSphere +static mrb_value +mrb_GetRayCollisionSphere(mrb_state* mrb, mrb_value self) { +Ray *parameter_ray; +Vector3 *parameter_center; +float parameter_radius; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ray"), +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ray = DATA_GET_PTR(mrb, kw_values[0], &mrb_Ray_struct, Ray); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_float(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *raycollision_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RayCollision_struct.struct_name); +RayCollision *return_of_GetRayCollisionSphere = (RayCollision *)mrb_malloc(mrb, sizeof(RayCollision)); + +*return_of_GetRayCollisionSphere = GetRayCollisionSphere(*parameter_ray, *parameter_center, parameter_radius); +return mrb_obj_value(Data_Wrap_Struct(mrb, raycollision_mrb_class, &mrb_RayCollision_struct, return_of_GetRayCollisionSphere)); +} + +//RayCollision GetRayCollisionTriangle +static mrb_value +mrb_GetRayCollisionTriangle(mrb_state* mrb, mrb_value self) { +Ray *parameter_ray; +Vector3 *parameter_p1; +Vector3 *parameter_p2; +Vector3 *parameter_p3; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "ray"), +mrb_intern_lit(mrb, "p1"), +mrb_intern_lit(mrb, "p2"), +mrb_intern_lit(mrb, "p3") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ray = DATA_GET_PTR(mrb, kw_values[0], &mrb_Ray_struct, Ray); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p1 = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p2 = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector3_struct, Vector3); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_p3 = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector3_struct, Vector3); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *raycollision_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RayCollision_struct.struct_name); +RayCollision *return_of_GetRayCollisionTriangle = (RayCollision *)mrb_malloc(mrb, sizeof(RayCollision)); + +*return_of_GetRayCollisionTriangle = GetRayCollisionTriangle(*parameter_ray, *parameter_p1, *parameter_p2, *parameter_p3); +return mrb_obj_value(Data_Wrap_Struct(mrb, raycollision_mrb_class, &mrb_RayCollision_struct, return_of_GetRayCollisionTriangle)); +} + +//int GetRenderHeight +static mrb_value +mrb_GetRenderHeight(mrb_state* mrb, mrb_value self) { +int return_of_GetRenderHeight; + +return_of_GetRenderHeight = GetRenderHeight(); +return mrb_fixnum_value(return_of_GetRenderHeight); +} + +//int GetRenderWidth +static mrb_value +mrb_GetRenderWidth(mrb_state* mrb, mrb_value self) { +int return_of_GetRenderWidth; + +return_of_GetRenderWidth = GetRenderWidth(); +return mrb_fixnum_value(return_of_GetRenderWidth); +} + +//int GetScreenHeight +static mrb_value +mrb_GetScreenHeight(mrb_state* mrb, mrb_value self) { +int return_of_GetScreenHeight; + +return_of_GetScreenHeight = GetScreenHeight(); +return mrb_fixnum_value(return_of_GetScreenHeight); +} + +//Vector2 GetScreenToWorld2D +static mrb_value +mrb_GetScreenToWorld2D(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_position; +Camera2D *parameter_camera; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "camera") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_camera = DATA_GET_PTR(mrb, kw_values[1], &mrb_Camera2D_struct, Camera2D); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetScreenToWorld2D = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetScreenToWorld2D = GetScreenToWorld2D(*parameter_position, *parameter_camera); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetScreenToWorld2D)); +} + +//int GetScreenWidth +static mrb_value +mrb_GetScreenWidth(mrb_state* mrb, mrb_value self) { +int return_of_GetScreenWidth; + +return_of_GetScreenWidth = GetScreenWidth(); +return mrb_fixnum_value(return_of_GetScreenWidth); +} + +//int GetShaderLocation +static mrb_value +mrb_GetShaderLocation(mrb_state* mrb, mrb_value self) { +Shader *parameter_shader; +char * parameter_uniformName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "shader"), +mrb_intern_lit(mrb, "uniformName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_shader = DATA_GET_PTR(mrb, kw_values[0], &mrb_Shader_struct, Shader); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_uniformName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +int return_of_GetShaderLocation; + +return_of_GetShaderLocation = GetShaderLocation(*parameter_shader, parameter_uniformName); +return mrb_fixnum_value(return_of_GetShaderLocation); +} + +//int GetShaderLocationAttrib +static mrb_value +mrb_GetShaderLocationAttrib(mrb_state* mrb, mrb_value self) { +Shader *parameter_shader; +char * parameter_attribName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "shader"), +mrb_intern_lit(mrb, "attribName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_shader = DATA_GET_PTR(mrb, kw_values[0], &mrb_Shader_struct, Shader); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_attribName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +int return_of_GetShaderLocationAttrib; + +return_of_GetShaderLocationAttrib = GetShaderLocationAttrib(*parameter_shader, parameter_attribName); +return mrb_fixnum_value(return_of_GetShaderLocationAttrib); +} + +//int GetSoundsPlaying +static mrb_value +mrb_GetSoundsPlaying(mrb_state* mrb, mrb_value self) { +int return_of_GetSoundsPlaying; + +return_of_GetSoundsPlaying = GetSoundsPlaying(); +return mrb_fixnum_value(return_of_GetSoundsPlaying); +} + +//double GetTime +static mrb_value +mrb_GetTime(mrb_state* mrb, mrb_value self) { +double return_of_GetTime; + +return_of_GetTime = GetTime(); +return mrb_float_value(mrb, return_of_GetTime); +} + +//int GetTouchPointCount +static mrb_value +mrb_GetTouchPointCount(mrb_state* mrb, mrb_value self) { +int return_of_GetTouchPointCount; + +return_of_GetTouchPointCount = GetTouchPointCount(); +return mrb_fixnum_value(return_of_GetTouchPointCount); +} + +//int GetTouchPointId +static mrb_value +mrb_GetTouchPointId(mrb_state* mrb, mrb_value self) { +mrb_int parameter_index; + +mrb_get_args(mrb, "i", ¶meter_index); +int return_of_GetTouchPointId; + +return_of_GetTouchPointId = GetTouchPointId(parameter_index); +return mrb_fixnum_value(return_of_GetTouchPointId); +} + +//Vector2 GetTouchPosition +static mrb_value +mrb_GetTouchPosition(mrb_state* mrb, mrb_value self) { +mrb_int parameter_index; + +mrb_get_args(mrb, "i", ¶meter_index); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetTouchPosition = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetTouchPosition = GetTouchPosition(parameter_index); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetTouchPosition)); +} + +//int GetTouchX +static mrb_value +mrb_GetTouchX(mrb_state* mrb, mrb_value self) { +int return_of_GetTouchX; + +return_of_GetTouchX = GetTouchX(); +return mrb_fixnum_value(return_of_GetTouchX); +} + +//int GetTouchY +static mrb_value +mrb_GetTouchY(mrb_state* mrb, mrb_value self) { +int return_of_GetTouchY; + +return_of_GetTouchY = GetTouchY(); +return mrb_fixnum_value(return_of_GetTouchY); +} + +//Vector2 GetWindowPosition +static mrb_value +mrb_GetWindowPosition(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetWindowPosition = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetWindowPosition = GetWindowPosition(); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetWindowPosition)); +} + +//Vector2 GetWindowScaleDPI +static mrb_value +mrb_GetWindowScaleDPI(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetWindowScaleDPI = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetWindowScaleDPI = GetWindowScaleDPI(); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetWindowScaleDPI)); +} + +//const char * GetWorkingDirectory +static mrb_value +mrb_GetWorkingDirectory(mrb_state* mrb, mrb_value self) { +const char * return_of_GetWorkingDirectory; + +return_of_GetWorkingDirectory = GetWorkingDirectory(); +return mrb_str_new_cstr(mrb, return_of_GetWorkingDirectory); +} + +//Vector2 GetWorldToScreen2D +static mrb_value +mrb_GetWorldToScreen2D(mrb_state* mrb, mrb_value self) { +Vector2 *parameter_position; +Camera2D *parameter_camera; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "camera") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[0], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_camera = DATA_GET_PTR(mrb, kw_values[1], &mrb_Camera2D_struct, Camera2D); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_GetWorldToScreen2D = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_GetWorldToScreen2D = GetWorldToScreen2D(*parameter_position, *parameter_camera); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_GetWorldToScreen2D)); +} + +//void HideCursor +static mrb_value +mrb_HideCursor(mrb_state* mrb, mrb_value self) { + +HideCursor(); +return mrb_nil_value(); +} + +//void ImageAlphaClear +static mrb_value +mrb_ImageAlphaClear(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Color *parameter_color; +float parameter_threshold; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "color"), +mrb_intern_lit(mrb, "threshold") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_threshold = mrb_as_float(mrb, kw_values[2]); +} + + +ImageAlphaClear(parameter_image, *parameter_color, parameter_threshold); +return mrb_nil_value(); +} + +//void ImageAlphaCrop +static mrb_value +mrb_ImageAlphaCrop(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +float parameter_threshold; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "threshold") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_threshold = mrb_as_float(mrb, kw_values[1]); +} + + +ImageAlphaCrop(parameter_image, parameter_threshold); +return mrb_nil_value(); +} + +//void ImageAlphaMask +static mrb_value +mrb_ImageAlphaMask(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Image *parameter_alphaMask; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "alphaMask") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_alphaMask = DATA_GET_PTR(mrb, kw_values[1], &mrb_Image_struct, Image); + +} + + +ImageAlphaMask(parameter_image, *parameter_alphaMask); +return mrb_nil_value(); +} + +//void ImageAlphaPremultiply +static mrb_value +mrb_ImageAlphaPremultiply(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageAlphaPremultiply(parameter_image); +return mrb_nil_value(); +} + +//void ImageClearBackground +static mrb_value +mrb_ImageClearBackground(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +ImageClearBackground(parameter_dst, *parameter_color); +return mrb_nil_value(); +} + +//void ImageColorBrightness +static mrb_value +mrb_ImageColorBrightness(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_brightness; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "brightness") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_brightness = mrb_as_int(mrb, kw_values[1]); +} + + +ImageColorBrightness(parameter_image, parameter_brightness); +return mrb_nil_value(); +} + +//void ImageColorContrast +static mrb_value +mrb_ImageColorContrast(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +float parameter_contrast; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "contrast") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_contrast = mrb_as_float(mrb, kw_values[1]); +} + + +ImageColorContrast(parameter_image, parameter_contrast); +return mrb_nil_value(); +} + +//void ImageColorGrayscale +static mrb_value +mrb_ImageColorGrayscale(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageColorGrayscale(parameter_image); +return mrb_nil_value(); +} + +//void ImageColorInvert +static mrb_value +mrb_ImageColorInvert(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageColorInvert(parameter_image); +return mrb_nil_value(); +} + +//void ImageColorReplace +static mrb_value +mrb_ImageColorReplace(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Color *parameter_color; +Color *parameter_replace; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "color"), +mrb_intern_lit(mrb, "replace") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_replace = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +ImageColorReplace(parameter_image, *parameter_color, *parameter_replace); +return mrb_nil_value(); +} + +//void ImageColorTint +static mrb_value +mrb_ImageColorTint(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Color *parameter_color; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +ImageColorTint(parameter_image, *parameter_color); +return mrb_nil_value(); +} + +//Image ImageCopy +static mrb_value +mrb_ImageCopy(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_ImageCopy = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_ImageCopy = ImageCopy(*parameter_image); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_ImageCopy)); +} + +//void ImageCrop +static mrb_value +mrb_ImageCrop(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Rectangle *parameter_crop; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "crop") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_crop = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + + +ImageCrop(parameter_image, *parameter_crop); +return mrb_nil_value(); +} + +//void ImageDither +static mrb_value +mrb_ImageDither(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_rBpp; +int parameter_gBpp; +int parameter_bBpp; +int parameter_aBpp; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "rBpp"), +mrb_intern_lit(mrb, "gBpp"), +mrb_intern_lit(mrb, "bBpp"), +mrb_intern_lit(mrb, "aBpp") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rBpp = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_gBpp = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_bBpp = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_aBpp = mrb_as_int(mrb, kw_values[4]); +} + + +ImageDither(parameter_image, parameter_rBpp, parameter_gBpp, parameter_bBpp, parameter_aBpp); +return mrb_nil_value(); +} + +//void ImageDraw +static mrb_value +mrb_ImageDraw(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Image *parameter_src; +Rectangle *parameter_srcRec; +Rectangle *parameter_dstRec; +Color *parameter_tint; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "src"), +mrb_intern_lit(mrb, "srcRec"), +mrb_intern_lit(mrb, "dstRec"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_src = DATA_GET_PTR(mrb, kw_values[1], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_srcRec = DATA_GET_PTR(mrb, kw_values[2], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dstRec = DATA_GET_PTR(mrb, kw_values[3], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +ImageDraw(parameter_dst, *parameter_src, *parameter_srcRec, *parameter_dstRec, *parameter_tint); +return mrb_nil_value(); +} + +//void ImageDrawCircle +static mrb_value +mrb_ImageDrawCircle(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +int parameter_centerX; +int parameter_centerY; +int parameter_radius; +Color *parameter_color; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "centerX"), +mrb_intern_lit(mrb, "centerY"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerX = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_centerY = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + + +ImageDrawCircle(parameter_dst, parameter_centerX, parameter_centerY, parameter_radius, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawCircleV +static mrb_value +mrb_ImageDrawCircleV(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Vector2 *parameter_center; +int parameter_radius; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "center"), +mrb_intern_lit(mrb, "radius"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_center = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_radius = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +ImageDrawCircleV(parameter_dst, *parameter_center, parameter_radius, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawLine +static mrb_value +mrb_ImageDrawLine(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +int parameter_startPosX; +int parameter_startPosY; +int parameter_endPosX; +int parameter_endPosY; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "startPosX"), +mrb_intern_lit(mrb, "startPosY"), +mrb_intern_lit(mrb, "endPosX"), +mrb_intern_lit(mrb, "endPosY"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPosX = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_startPosY = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPosX = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_endPosY = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +ImageDrawLine(parameter_dst, parameter_startPosX, parameter_startPosY, parameter_endPosX, parameter_endPosY, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawLineV +static mrb_value +mrb_ImageDrawLineV(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Vector2 *parameter_start; +Vector2 *parameter_end; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "start"), +mrb_intern_lit(mrb, "end"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_start = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_end = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +ImageDrawLineV(parameter_dst, *parameter_start, *parameter_end, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawPixel +static mrb_value +mrb_ImageDrawPixel(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +int parameter_posX; +int parameter_posY; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +ImageDrawPixel(parameter_dst, parameter_posX, parameter_posY, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawPixelV +static mrb_value +mrb_ImageDrawPixelV(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Vector2 *parameter_position; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +ImageDrawPixelV(parameter_dst, *parameter_position, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawRectangle +static mrb_value +mrb_ImageDrawRectangle(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +int parameter_posX; +int parameter_posY; +int parameter_width; +int parameter_height; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +ImageDrawRectangle(parameter_dst, parameter_posX, parameter_posY, parameter_width, parameter_height, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawRectangleLines +static mrb_value +mrb_ImageDrawRectangleLines(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Rectangle *parameter_rec; +int parameter_thick; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "thick"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_thick = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +ImageDrawRectangleLines(parameter_dst, *parameter_rec, parameter_thick, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawRectangleRec +static mrb_value +mrb_ImageDrawRectangleRec(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Rectangle *parameter_rec; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "rec"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + + +ImageDrawRectangleRec(parameter_dst, *parameter_rec, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawRectangleV +static mrb_value +mrb_ImageDrawRectangleV(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Vector2 *parameter_position; +Vector2 *parameter_size; +Color *parameter_color; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "size"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[1], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_size = DATA_GET_PTR(mrb, kw_values[2], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[3], &mrb_Color_struct, Color); + +} + + +ImageDrawRectangleV(parameter_dst, *parameter_position, *parameter_size, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawText +static mrb_value +mrb_ImageDrawText(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +char * parameter_text; +int parameter_posX; +int parameter_posY; +int parameter_fontSize; +Color *parameter_color; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "posX"), +mrb_intern_lit(mrb, "posY"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posX = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_posY = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +ImageDrawText(parameter_dst, parameter_text, parameter_posX, parameter_posY, parameter_fontSize, *parameter_color); +return mrb_nil_value(); +} + +//void ImageDrawTextEx +static mrb_value +mrb_ImageDrawTextEx(mrb_state* mrb, mrb_value self) { +Image *parameter_dst; +Font *parameter_font; +char * parameter_text; +Vector2 *parameter_position; +float parameter_fontSize; +float parameter_spacing; +Color *parameter_tint; + +uint32_t kw_num = 7; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "spacing"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[1], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = DATA_GET_PTR(mrb, kw_values[3], &mrb_Vector2_struct, Vector2); + +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_float(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_spacing = mrb_as_float(mrb, kw_values[5]); +} + +if (mrb_undef_p(kw_values[6])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[6], &mrb_Color_struct, Color); + +} + + +ImageDrawTextEx(parameter_dst, *parameter_font, parameter_text, *parameter_position, parameter_fontSize, parameter_spacing, *parameter_tint); +return mrb_nil_value(); +} + +//void ImageFlipHorizontal +static mrb_value +mrb_ImageFlipHorizontal(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageFlipHorizontal(parameter_image); +return mrb_nil_value(); +} + +//void ImageFlipVertical +static mrb_value +mrb_ImageFlipVertical(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageFlipVertical(parameter_image); +return mrb_nil_value(); +} + +//void ImageFormat +static mrb_value +mrb_ImageFormat(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_newFormat; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "newFormat") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newFormat = mrb_as_int(mrb, kw_values[1]); +} + + +ImageFormat(parameter_image, parameter_newFormat); +return mrb_nil_value(); +} + +//Image ImageFromImage +static mrb_value +mrb_ImageFromImage(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Rectangle *parameter_rec; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "rec") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_rec = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_ImageFromImage = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_ImageFromImage = ImageFromImage(*parameter_image, *parameter_rec); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_ImageFromImage)); +} + +//void ImageMipmaps +static mrb_value +mrb_ImageMipmaps(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageMipmaps(parameter_image); +return mrb_nil_value(); +} + +//void ImageResize +static mrb_value +mrb_ImageResize(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_newWidth; +int parameter_newHeight; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "newWidth"), +mrb_intern_lit(mrb, "newHeight") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newWidth = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newHeight = mrb_as_int(mrb, kw_values[2]); +} + + +ImageResize(parameter_image, parameter_newWidth, parameter_newHeight); +return mrb_nil_value(); +} + +//void ImageResizeCanvas +static mrb_value +mrb_ImageResizeCanvas(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_newWidth; +int parameter_newHeight; +int parameter_offsetX; +int parameter_offsetY; +Color *parameter_fill; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "newWidth"), +mrb_intern_lit(mrb, "newHeight"), +mrb_intern_lit(mrb, "offsetX"), +mrb_intern_lit(mrb, "offsetY"), +mrb_intern_lit(mrb, "fill") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newWidth = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newHeight = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_offsetX = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_offsetY = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fill = DATA_GET_PTR(mrb, kw_values[5], &mrb_Color_struct, Color); + +} + + +ImageResizeCanvas(parameter_image, parameter_newWidth, parameter_newHeight, parameter_offsetX, parameter_offsetY, *parameter_fill); +return mrb_nil_value(); +} + +//void ImageResizeNN +static mrb_value +mrb_ImageResizeNN(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_newWidth; +int parameter_newHeight; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "newWidth"), +mrb_intern_lit(mrb, "newHeight") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newWidth = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_newHeight = mrb_as_int(mrb, kw_values[2]); +} + + +ImageResizeNN(parameter_image, parameter_newWidth, parameter_newHeight); +return mrb_nil_value(); +} + +//void ImageRotateCCW +static mrb_value +mrb_ImageRotateCCW(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageRotateCCW(parameter_image); +return mrb_nil_value(); +} + +//void ImageRotateCW +static mrb_value +mrb_ImageRotateCW(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +ImageRotateCW(parameter_image); +return mrb_nil_value(); +} + +//Image ImageText +static mrb_value +mrb_ImageText(mrb_state* mrb, mrb_value self) { +char * parameter_text; +int parameter_fontSize; +Color *parameter_color; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "color") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_color = DATA_GET_PTR(mrb, kw_values[2], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_ImageText = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_ImageText = ImageText(parameter_text, parameter_fontSize, *parameter_color); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_ImageText)); +} + +//Image ImageTextEx +static mrb_value +mrb_ImageTextEx(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +char * parameter_text; +float parameter_fontSize; +float parameter_spacing; +Color *parameter_tint; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "spacing"), +mrb_intern_lit(mrb, "tint") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_spacing = mrb_as_float(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_tint = DATA_GET_PTR(mrb, kw_values[4], &mrb_Color_struct, Color); + +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_ImageTextEx = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_ImageTextEx = ImageTextEx(*parameter_font, parameter_text, parameter_fontSize, parameter_spacing, *parameter_tint); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_ImageTextEx)); +} + +//void ImageToPOT +static mrb_value +mrb_ImageToPOT(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Color *parameter_fill; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "fill") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fill = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + + +ImageToPOT(parameter_image, *parameter_fill); +return mrb_nil_value(); +} + +//void InitAudioDevice +static mrb_value +mrb_InitAudioDevice(mrb_state* mrb, mrb_value self) { + +InitAudioDevice(); +return mrb_nil_value(); +} + +//void InitWindow +static mrb_value +mrb_InitWindow(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; +char * parameter_title; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "title") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_title = mrb_str_to_cstr(mrb, kw_values[2]); +} + + +InitWindow(parameter_width, parameter_height, parameter_title); +return mrb_nil_value(); +} + +//bool IsAudioDeviceReady +static mrb_value +mrb_IsAudioDeviceReady(mrb_state* mrb, mrb_value self) { +bool return_of_IsAudioDeviceReady; + +return_of_IsAudioDeviceReady = IsAudioDeviceReady(); +return mrb_bool_value(return_of_IsAudioDeviceReady); +} + +//bool IsAudioStreamPlaying +static mrb_value +mrb_IsAudioStreamPlaying(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); +bool return_of_IsAudioStreamPlaying; + +return_of_IsAudioStreamPlaying = IsAudioStreamPlaying(*parameter_stream); +return mrb_bool_value(return_of_IsAudioStreamPlaying); +} + +//bool IsAudioStreamProcessed +static mrb_value +mrb_IsAudioStreamProcessed(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); +bool return_of_IsAudioStreamProcessed; + +return_of_IsAudioStreamProcessed = IsAudioStreamProcessed(*parameter_stream); +return mrb_bool_value(return_of_IsAudioStreamProcessed); +} + +//bool IsCursorHidden +static mrb_value +mrb_IsCursorHidden(mrb_state* mrb, mrb_value self) { +bool return_of_IsCursorHidden; + +return_of_IsCursorHidden = IsCursorHidden(); +return mrb_bool_value(return_of_IsCursorHidden); +} + +//bool IsCursorOnScreen +static mrb_value +mrb_IsCursorOnScreen(mrb_state* mrb, mrb_value self) { +bool return_of_IsCursorOnScreen; + +return_of_IsCursorOnScreen = IsCursorOnScreen(); +return mrb_bool_value(return_of_IsCursorOnScreen); +} + +//bool IsFileDropped +static mrb_value +mrb_IsFileDropped(mrb_state* mrb, mrb_value self) { +bool return_of_IsFileDropped; + +return_of_IsFileDropped = IsFileDropped(); +return mrb_bool_value(return_of_IsFileDropped); +} + +//bool IsFileExtension +static mrb_value +mrb_IsFileExtension(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +char * parameter_ext; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "ext") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_ext = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_IsFileExtension; + +return_of_IsFileExtension = IsFileExtension(parameter_fileName, parameter_ext); +return mrb_bool_value(return_of_IsFileExtension); +} + +//bool IsGamepadAvailable +static mrb_value +mrb_IsGamepadAvailable(mrb_state* mrb, mrb_value self) { +mrb_int parameter_gamepad; + +mrb_get_args(mrb, "i", ¶meter_gamepad); +bool return_of_IsGamepadAvailable; + +return_of_IsGamepadAvailable = IsGamepadAvailable(parameter_gamepad); +return mrb_bool_value(return_of_IsGamepadAvailable); +} + +//bool IsGamepadButtonDown +static mrb_value +mrb_IsGamepadButtonDown(mrb_state* mrb, mrb_value self) { +int parameter_gamepad; +int parameter_button; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "gamepad"), +mrb_intern_lit(mrb, "button") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_gamepad = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_button = mrb_as_int(mrb, kw_values[1]); +} + +bool return_of_IsGamepadButtonDown; + +return_of_IsGamepadButtonDown = IsGamepadButtonDown(parameter_gamepad, parameter_button); +return mrb_bool_value(return_of_IsGamepadButtonDown); +} + +//bool IsGamepadButtonPressed +static mrb_value +mrb_IsGamepadButtonPressed(mrb_state* mrb, mrb_value self) { +int parameter_gamepad; +int parameter_button; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "gamepad"), +mrb_intern_lit(mrb, "button") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_gamepad = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_button = mrb_as_int(mrb, kw_values[1]); +} + +bool return_of_IsGamepadButtonPressed; + +return_of_IsGamepadButtonPressed = IsGamepadButtonPressed(parameter_gamepad, parameter_button); +return mrb_bool_value(return_of_IsGamepadButtonPressed); +} + +//bool IsGamepadButtonReleased +static mrb_value +mrb_IsGamepadButtonReleased(mrb_state* mrb, mrb_value self) { +int parameter_gamepad; +int parameter_button; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "gamepad"), +mrb_intern_lit(mrb, "button") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_gamepad = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_button = mrb_as_int(mrb, kw_values[1]); +} + +bool return_of_IsGamepadButtonReleased; + +return_of_IsGamepadButtonReleased = IsGamepadButtonReleased(parameter_gamepad, parameter_button); +return mrb_bool_value(return_of_IsGamepadButtonReleased); +} + +//bool IsGamepadButtonUp +static mrb_value +mrb_IsGamepadButtonUp(mrb_state* mrb, mrb_value self) { +int parameter_gamepad; +int parameter_button; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "gamepad"), +mrb_intern_lit(mrb, "button") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_gamepad = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_button = mrb_as_int(mrb, kw_values[1]); +} + +bool return_of_IsGamepadButtonUp; + +return_of_IsGamepadButtonUp = IsGamepadButtonUp(parameter_gamepad, parameter_button); +return mrb_bool_value(return_of_IsGamepadButtonUp); +} + +//bool IsGestureDetected +static mrb_value +mrb_IsGestureDetected(mrb_state* mrb, mrb_value self) { +mrb_int parameter_gesture; + +mrb_get_args(mrb, "i", ¶meter_gesture); +bool return_of_IsGestureDetected; + +return_of_IsGestureDetected = IsGestureDetected(parameter_gesture); +return mrb_bool_value(return_of_IsGestureDetected); +} + +//bool IsKeyDown +static mrb_value +mrb_IsKeyDown(mrb_state* mrb, mrb_value self) { +mrb_int parameter_key; + +mrb_get_args(mrb, "i", ¶meter_key); +bool return_of_IsKeyDown; + +return_of_IsKeyDown = IsKeyDown(parameter_key); +return mrb_bool_value(return_of_IsKeyDown); +} + +//bool IsKeyPressed +static mrb_value +mrb_IsKeyPressed(mrb_state* mrb, mrb_value self) { +mrb_int parameter_key; + +mrb_get_args(mrb, "i", ¶meter_key); +bool return_of_IsKeyPressed; + +return_of_IsKeyPressed = IsKeyPressed(parameter_key); +return mrb_bool_value(return_of_IsKeyPressed); +} + +//bool IsKeyReleased +static mrb_value +mrb_IsKeyReleased(mrb_state* mrb, mrb_value self) { +mrb_int parameter_key; + +mrb_get_args(mrb, "i", ¶meter_key); +bool return_of_IsKeyReleased; + +return_of_IsKeyReleased = IsKeyReleased(parameter_key); +return mrb_bool_value(return_of_IsKeyReleased); +} + +//bool IsKeyUp +static mrb_value +mrb_IsKeyUp(mrb_state* mrb, mrb_value self) { +mrb_int parameter_key; + +mrb_get_args(mrb, "i", ¶meter_key); +bool return_of_IsKeyUp; + +return_of_IsKeyUp = IsKeyUp(parameter_key); +return mrb_bool_value(return_of_IsKeyUp); +} + +//bool IsModelAnimationValid +static mrb_value +mrb_IsModelAnimationValid(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +ModelAnimation *parameter_anim; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "anim") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_anim = DATA_GET_PTR(mrb, kw_values[1], &mrb_ModelAnimation_struct, ModelAnimation); + +} + +bool return_of_IsModelAnimationValid; + +return_of_IsModelAnimationValid = IsModelAnimationValid(*parameter_model, *parameter_anim); +return mrb_bool_value(return_of_IsModelAnimationValid); +} + +//bool IsMouseButtonDown +static mrb_value +mrb_IsMouseButtonDown(mrb_state* mrb, mrb_value self) { +mrb_int parameter_button; + +mrb_get_args(mrb, "i", ¶meter_button); +bool return_of_IsMouseButtonDown; + +return_of_IsMouseButtonDown = IsMouseButtonDown(parameter_button); +return mrb_bool_value(return_of_IsMouseButtonDown); +} + +//bool IsMouseButtonPressed +static mrb_value +mrb_IsMouseButtonPressed(mrb_state* mrb, mrb_value self) { +mrb_int parameter_button; + +mrb_get_args(mrb, "i", ¶meter_button); +bool return_of_IsMouseButtonPressed; + +return_of_IsMouseButtonPressed = IsMouseButtonPressed(parameter_button); +return mrb_bool_value(return_of_IsMouseButtonPressed); +} + +//bool IsMouseButtonReleased +static mrb_value +mrb_IsMouseButtonReleased(mrb_state* mrb, mrb_value self) { +mrb_int parameter_button; + +mrb_get_args(mrb, "i", ¶meter_button); +bool return_of_IsMouseButtonReleased; + +return_of_IsMouseButtonReleased = IsMouseButtonReleased(parameter_button); +return mrb_bool_value(return_of_IsMouseButtonReleased); +} + +//bool IsMouseButtonUp +static mrb_value +mrb_IsMouseButtonUp(mrb_state* mrb, mrb_value self) { +mrb_int parameter_button; + +mrb_get_args(mrb, "i", ¶meter_button); +bool return_of_IsMouseButtonUp; + +return_of_IsMouseButtonUp = IsMouseButtonUp(parameter_button); +return mrb_bool_value(return_of_IsMouseButtonUp); +} + +//bool IsMusicStreamPlaying +static mrb_value +mrb_IsMusicStreamPlaying(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); +bool return_of_IsMusicStreamPlaying; + +return_of_IsMusicStreamPlaying = IsMusicStreamPlaying(*parameter_music); +return mrb_bool_value(return_of_IsMusicStreamPlaying); +} + +//bool IsSoundPlaying +static mrb_value +mrb_IsSoundPlaying(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); +bool return_of_IsSoundPlaying; + +return_of_IsSoundPlaying = IsSoundPlaying(*parameter_sound); +return mrb_bool_value(return_of_IsSoundPlaying); +} + +//bool IsWindowFocused +static mrb_value +mrb_IsWindowFocused(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowFocused; + +return_of_IsWindowFocused = IsWindowFocused(); +return mrb_bool_value(return_of_IsWindowFocused); +} + +//bool IsWindowFullscreen +static mrb_value +mrb_IsWindowFullscreen(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowFullscreen; + +return_of_IsWindowFullscreen = IsWindowFullscreen(); +return mrb_bool_value(return_of_IsWindowFullscreen); +} + +//bool IsWindowHidden +static mrb_value +mrb_IsWindowHidden(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowHidden; + +return_of_IsWindowHidden = IsWindowHidden(); +return mrb_bool_value(return_of_IsWindowHidden); +} + +//bool IsWindowMaximized +static mrb_value +mrb_IsWindowMaximized(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowMaximized; + +return_of_IsWindowMaximized = IsWindowMaximized(); +return mrb_bool_value(return_of_IsWindowMaximized); +} + +//bool IsWindowMinimized +static mrb_value +mrb_IsWindowMinimized(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowMinimized; + +return_of_IsWindowMinimized = IsWindowMinimized(); +return mrb_bool_value(return_of_IsWindowMinimized); +} + +//bool IsWindowReady +static mrb_value +mrb_IsWindowReady(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowReady; + +return_of_IsWindowReady = IsWindowReady(); +return mrb_bool_value(return_of_IsWindowReady); +} + +//bool IsWindowResized +static mrb_value +mrb_IsWindowResized(mrb_state* mrb, mrb_value self) { +bool return_of_IsWindowResized; + +return_of_IsWindowResized = IsWindowResized(); +return mrb_bool_value(return_of_IsWindowResized); +} + +//bool IsWindowState +static mrb_value +mrb_IsWindowState(mrb_state* mrb, mrb_value self) { +mrb_int parameter_flag; + +mrb_get_args(mrb, "i", ¶meter_flag); +bool return_of_IsWindowState; + +return_of_IsWindowState = IsWindowState(parameter_flag); +return mrb_bool_value(return_of_IsWindowState); +} + +//AudioStream LoadAudioStream +static mrb_value +mrb_LoadAudioStream(mrb_state* mrb, mrb_value self) { +int parameter_sampleRate; +int parameter_sampleSize; +int parameter_channels; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "sampleRate"), +mrb_intern_lit(mrb, "sampleSize"), +mrb_intern_lit(mrb, "channels") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sampleRate = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sampleSize = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_channels = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *audiostream_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_AudioStream_struct.struct_name); +AudioStream *return_of_LoadAudioStream = (AudioStream *)mrb_malloc(mrb, sizeof(AudioStream)); + +*return_of_LoadAudioStream = LoadAudioStream(parameter_sampleRate, parameter_sampleSize, parameter_channels); +return mrb_obj_value(Data_Wrap_Struct(mrb, audiostream_mrb_class, &mrb_AudioStream_struct, return_of_LoadAudioStream)); +} + +//int * LoadCodepoints +static mrb_value +mrb_LoadCodepoints(mrb_state* mrb, mrb_value self) { +char * parameter_text; +int parameter_count; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "count") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_count = mrb_as_int(mrb, kw_values[1]); +} + +int * return_of_LoadCodepoints; + +return_of_LoadCodepoints = LoadCodepoints(parameter_text, (int *)¶meter_count); +return mrb_fixnum_value(*return_of_LoadCodepoints); +} + +//unsigned char * LoadFileData +static mrb_value +mrb_LoadFileData(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +int parameter_bytesRead; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "bytesRead") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_bytesRead = mrb_as_int(mrb, kw_values[1]); +} + +unsigned char * return_of_LoadFileData; + +return_of_LoadFileData = LoadFileData(parameter_fileName, (unsigned int *)¶meter_bytesRead); +return mrb_fixnum_value(*return_of_LoadFileData); +} + +//char * LoadFileText +static mrb_value +mrb_LoadFileText(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +char * return_of_LoadFileText; + +return_of_LoadFileText = LoadFileText(parameter_fileName); +return mrb_str_new_cstr(mrb, return_of_LoadFileText); +} + +//Font LoadFont +static mrb_value +mrb_LoadFont(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *font_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Font_struct.struct_name); +Font *return_of_LoadFont = (Font *)mrb_malloc(mrb, sizeof(Font)); + +*return_of_LoadFont = LoadFont(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, font_mrb_class, &mrb_Font_struct, return_of_LoadFont)); +} + +//Font LoadFontEx +static mrb_value +mrb_LoadFontEx(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +int parameter_fontSize; +int parameter_fontChars; +int parameter_glyphCount; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "fontChars"), +mrb_intern_lit(mrb, "glyphCount") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontChars = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_glyphCount = mrb_as_int(mrb, kw_values[3]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *font_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Font_struct.struct_name); +Font *return_of_LoadFontEx = (Font *)mrb_malloc(mrb, sizeof(Font)); + +*return_of_LoadFontEx = LoadFontEx(parameter_fileName, parameter_fontSize, (int *)¶meter_fontChars, parameter_glyphCount); +return mrb_obj_value(Data_Wrap_Struct(mrb, font_mrb_class, &mrb_Font_struct, return_of_LoadFontEx)); +} + +//Font LoadFontFromImage +static mrb_value +mrb_LoadFontFromImage(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +Color *parameter_key; +int parameter_firstChar; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "key"), +mrb_intern_lit(mrb, "firstChar") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_key = DATA_GET_PTR(mrb, kw_values[1], &mrb_Color_struct, Color); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_firstChar = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *font_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Font_struct.struct_name); +Font *return_of_LoadFontFromImage = (Font *)mrb_malloc(mrb, sizeof(Font)); + +*return_of_LoadFontFromImage = LoadFontFromImage(*parameter_image, *parameter_key, parameter_firstChar); +return mrb_obj_value(Data_Wrap_Struct(mrb, font_mrb_class, &mrb_Font_struct, return_of_LoadFontFromImage)); +} + +//Image LoadImage +static mrb_value +mrb_LoadImage(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_LoadImage = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_LoadImage = LoadImage(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_LoadImage)); +} + +//Image LoadImageAnim +static mrb_value +mrb_LoadImageAnim(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +int parameter_frames; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "frames") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_frames = mrb_as_int(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_LoadImageAnim = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_LoadImageAnim = LoadImageAnim(parameter_fileName, (int *)¶meter_frames); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_LoadImageAnim)); +} + +//Color * LoadImageColors +static mrb_value +mrb_LoadImageColors(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_LoadImageColors = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_LoadImageColors = *LoadImageColors(*parameter_image); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_LoadImageColors)); +} + +//Image LoadImageFromScreen +static mrb_value +mrb_LoadImageFromScreen(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_LoadImageFromScreen = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_LoadImageFromScreen = LoadImageFromScreen(); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_LoadImageFromScreen)); +} + +//Image LoadImageFromTexture +static mrb_value +mrb_LoadImageFromTexture(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_texture; + +mrb_get_args(mrb, "o", ¶meter_mrb_texture); +Texture *parameter_texture; +parameter_texture = DATA_GET_PTR(mrb, parameter_mrb_texture, &mrb_Texture_struct, Texture); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_LoadImageFromTexture = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_LoadImageFromTexture = LoadImageFromTexture(*parameter_texture); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_LoadImageFromTexture)); +} + +//Color * LoadImagePalette +static mrb_value +mrb_LoadImagePalette(mrb_state* mrb, mrb_value self) { +Image *parameter_image; +int parameter_maxPaletteSize; +int parameter_colorCount; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "image"), +mrb_intern_lit(mrb, "maxPaletteSize"), +mrb_intern_lit(mrb, "colorCount") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_image = DATA_GET_PTR(mrb, kw_values[0], &mrb_Image_struct, Image); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_maxPaletteSize = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_colorCount = mrb_as_int(mrb, kw_values[2]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *color_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Color_struct.struct_name); +Color *return_of_LoadImagePalette = (Color *)mrb_malloc(mrb, sizeof(Color)); + +*return_of_LoadImagePalette = *LoadImagePalette(*parameter_image, parameter_maxPaletteSize, (int *)¶meter_colorCount); +return mrb_obj_value(Data_Wrap_Struct(mrb, color_mrb_class, &mrb_Color_struct, return_of_LoadImagePalette)); +} + +//Image LoadImageRaw +static mrb_value +mrb_LoadImageRaw(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +int parameter_width; +int parameter_height; +int parameter_format; +int parameter_headerSize; + +uint32_t kw_num = 5; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height"), +mrb_intern_lit(mrb, "format"), +mrb_intern_lit(mrb, "headerSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_format = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_headerSize = mrb_as_int(mrb, kw_values[4]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *image_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Image_struct.struct_name); +Image *return_of_LoadImageRaw = (Image *)mrb_malloc(mrb, sizeof(Image)); + +*return_of_LoadImageRaw = LoadImageRaw(parameter_fileName, parameter_width, parameter_height, parameter_format, parameter_headerSize); +return mrb_obj_value(Data_Wrap_Struct(mrb, image_mrb_class, &mrb_Image_struct, return_of_LoadImageRaw)); +} + +//Material LoadMaterialDefault +static mrb_value +mrb_LoadMaterialDefault(mrb_state* mrb, mrb_value self) { +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *material_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Material_struct.struct_name); +Material *return_of_LoadMaterialDefault = (Material *)mrb_malloc(mrb, sizeof(Material)); + +*return_of_LoadMaterialDefault = LoadMaterialDefault(); +return mrb_obj_value(Data_Wrap_Struct(mrb, material_mrb_class, &mrb_Material_struct, return_of_LoadMaterialDefault)); +} + +//Material * LoadMaterials +static mrb_value +mrb_LoadMaterials(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +int parameter_materialCount; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "materialCount") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_materialCount = mrb_as_int(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *material_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Material_struct.struct_name); +Material *return_of_LoadMaterials = (Material *)mrb_malloc(mrb, sizeof(Material)); + +*return_of_LoadMaterials = *LoadMaterials(parameter_fileName, (int *)¶meter_materialCount); +return mrb_obj_value(Data_Wrap_Struct(mrb, material_mrb_class, &mrb_Material_struct, return_of_LoadMaterials)); +} + +//Model LoadModel +static mrb_value +mrb_LoadModel(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *model_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Model_struct.struct_name); +Model *return_of_LoadModel = (Model *)mrb_malloc(mrb, sizeof(Model)); + +*return_of_LoadModel = LoadModel(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, model_mrb_class, &mrb_Model_struct, return_of_LoadModel)); +} + +//ModelAnimation * LoadModelAnimations +static mrb_value +mrb_LoadModelAnimations(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +int parameter_animCount; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "animCount") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_animCount = mrb_as_int(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *modelanimation_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_ModelAnimation_struct.struct_name); +ModelAnimation *return_of_LoadModelAnimations = (ModelAnimation *)mrb_malloc(mrb, sizeof(ModelAnimation)); + +*return_of_LoadModelAnimations = *LoadModelAnimations(parameter_fileName, (unsigned int *)¶meter_animCount); +return mrb_obj_value(Data_Wrap_Struct(mrb, modelanimation_mrb_class, &mrb_ModelAnimation_struct, return_of_LoadModelAnimations)); +} + +//Model LoadModelFromMesh +static mrb_value +mrb_LoadModelFromMesh(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_mesh; + +mrb_get_args(mrb, "o", ¶meter_mrb_mesh); +Mesh *parameter_mesh; +parameter_mesh = DATA_GET_PTR(mrb, parameter_mrb_mesh, &mrb_Mesh_struct, Mesh); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *model_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Model_struct.struct_name); +Model *return_of_LoadModelFromMesh = (Model *)mrb_malloc(mrb, sizeof(Model)); + +*return_of_LoadModelFromMesh = LoadModelFromMesh(*parameter_mesh); +return mrb_obj_value(Data_Wrap_Struct(mrb, model_mrb_class, &mrb_Model_struct, return_of_LoadModelFromMesh)); +} + +//Music LoadMusicStream +static mrb_value +mrb_LoadMusicStream(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *music_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Music_struct.struct_name); +Music *return_of_LoadMusicStream = (Music *)mrb_malloc(mrb, sizeof(Music)); + +*return_of_LoadMusicStream = LoadMusicStream(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, music_mrb_class, &mrb_Music_struct, return_of_LoadMusicStream)); +} + +//Shader LoadShader +static mrb_value +mrb_LoadShader(mrb_state* mrb, mrb_value self) { +char * parameter_vsFileName; +char * parameter_fsFileName; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "vsFileName"), +mrb_intern_lit(mrb, "fsFileName") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_vsFileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fsFileName = mrb_str_to_cstr(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *shader_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Shader_struct.struct_name); +Shader *return_of_LoadShader = (Shader *)mrb_malloc(mrb, sizeof(Shader)); + +*return_of_LoadShader = LoadShader(parameter_vsFileName, parameter_fsFileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, shader_mrb_class, &mrb_Shader_struct, return_of_LoadShader)); +} + +//Shader LoadShaderFromMemory +static mrb_value +mrb_LoadShaderFromMemory(mrb_state* mrb, mrb_value self) { +char * parameter_vsCode; +char * parameter_fsCode; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "vsCode"), +mrb_intern_lit(mrb, "fsCode") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_vsCode = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fsCode = mrb_str_to_cstr(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *shader_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Shader_struct.struct_name); +Shader *return_of_LoadShaderFromMemory = (Shader *)mrb_malloc(mrb, sizeof(Shader)); + +*return_of_LoadShaderFromMemory = LoadShaderFromMemory(parameter_vsCode, parameter_fsCode); +return mrb_obj_value(Data_Wrap_Struct(mrb, shader_mrb_class, &mrb_Shader_struct, return_of_LoadShaderFromMemory)); +} + +//Sound LoadSound +static mrb_value +mrb_LoadSound(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *sound_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Sound_struct.struct_name); +Sound *return_of_LoadSound = (Sound *)mrb_malloc(mrb, sizeof(Sound)); + +*return_of_LoadSound = LoadSound(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, sound_mrb_class, &mrb_Sound_struct, return_of_LoadSound)); +} + +//Sound LoadSoundFromWave +static mrb_value +mrb_LoadSoundFromWave(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_wave; + +mrb_get_args(mrb, "o", ¶meter_mrb_wave); +Wave *parameter_wave; +parameter_wave = DATA_GET_PTR(mrb, parameter_mrb_wave, &mrb_Wave_struct, Wave); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *sound_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Sound_struct.struct_name); +Sound *return_of_LoadSoundFromWave = (Sound *)mrb_malloc(mrb, sizeof(Sound)); + +*return_of_LoadSoundFromWave = LoadSoundFromWave(*parameter_wave); +return mrb_obj_value(Data_Wrap_Struct(mrb, sound_mrb_class, &mrb_Sound_struct, return_of_LoadSoundFromWave)); +} + +//int LoadStorageValue +static mrb_value +mrb_LoadStorageValue(mrb_state* mrb, mrb_value self) { +mrb_int parameter_position; + +mrb_get_args(mrb, "i", ¶meter_position); +int return_of_LoadStorageValue; + +return_of_LoadStorageValue = LoadStorageValue(parameter_position); +return mrb_fixnum_value(return_of_LoadStorageValue); +} + +//VrStereoConfig LoadVrStereoConfig +static mrb_value +mrb_LoadVrStereoConfig(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_device; + +mrb_get_args(mrb, "o", ¶meter_mrb_device); +VrDeviceInfo *parameter_device; +parameter_device = DATA_GET_PTR(mrb, parameter_mrb_device, &mrb_VrDeviceInfo_struct, VrDeviceInfo); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vrstereoconfig_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_VrStereoConfig_struct.struct_name); +VrStereoConfig *return_of_LoadVrStereoConfig = (VrStereoConfig *)mrb_malloc(mrb, sizeof(VrStereoConfig)); + +*return_of_LoadVrStereoConfig = LoadVrStereoConfig(*parameter_device); +return mrb_obj_value(Data_Wrap_Struct(mrb, vrstereoconfig_mrb_class, &mrb_VrStereoConfig_struct, return_of_LoadVrStereoConfig)); +} + +//Wave LoadWave +static mrb_value +mrb_LoadWave(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *wave_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Wave_struct.struct_name); +Wave *return_of_LoadWave = (Wave *)mrb_malloc(mrb, sizeof(Wave)); + +*return_of_LoadWave = LoadWave(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, wave_mrb_class, &mrb_Wave_struct, return_of_LoadWave)); +} + +//float * LoadWaveSamples +static mrb_value +mrb_LoadWaveSamples(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_wave; + +mrb_get_args(mrb, "o", ¶meter_mrb_wave); +Wave *parameter_wave; +parameter_wave = DATA_GET_PTR(mrb, parameter_mrb_wave, &mrb_Wave_struct, Wave); +float * return_of_LoadWaveSamples; + +return_of_LoadWaveSamples = LoadWaveSamples(*parameter_wave); +return mrb_float_value(mrb, *return_of_LoadWaveSamples); +} + +//void MaximizeWindow +static mrb_value +mrb_MaximizeWindow(mrb_state* mrb, mrb_value self) { + +MaximizeWindow(); +return mrb_nil_value(); +} + +//int MeasureText +static mrb_value +mrb_MeasureText(mrb_state* mrb, mrb_value self) { +char * parameter_text; +int parameter_fontSize; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "fontSize") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_int(mrb, kw_values[1]); +} + +int return_of_MeasureText; + +return_of_MeasureText = MeasureText(parameter_text, parameter_fontSize); +return mrb_fixnum_value(return_of_MeasureText); +} + +//Vector2 MeasureTextEx +static mrb_value +mrb_MeasureTextEx(mrb_state* mrb, mrb_value self) { +Font *parameter_font; +char * parameter_text; +float parameter_fontSize; +float parameter_spacing; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "font"), +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "fontSize"), +mrb_intern_lit(mrb, "spacing") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_font = DATA_GET_PTR(mrb, kw_values[0], &mrb_Font_struct, Font); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fontSize = mrb_as_float(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_spacing = mrb_as_float(mrb, kw_values[3]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *vector2_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Vector2_struct.struct_name); +Vector2 *return_of_MeasureTextEx = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); + +*return_of_MeasureTextEx = MeasureTextEx(*parameter_font, parameter_text, parameter_fontSize, parameter_spacing); +return mrb_obj_value(Data_Wrap_Struct(mrb, vector2_mrb_class, &mrb_Vector2_struct, return_of_MeasureTextEx)); +} + +//void MinimizeWindow +static mrb_value +mrb_MinimizeWindow(mrb_state* mrb, mrb_value self) { + +MinimizeWindow(); +return mrb_nil_value(); +} + +//void OpenURL +static mrb_value +mrb_OpenURL(mrb_state* mrb, mrb_value self) { +char * parameter_url; + +mrb_get_args(mrb, "z", ¶meter_url); + +OpenURL(parameter_url); +return mrb_nil_value(); +} + +//void PauseAudioStream +static mrb_value +mrb_PauseAudioStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); + +PauseAudioStream(*parameter_stream); +return mrb_nil_value(); +} + +//void PauseMusicStream +static mrb_value +mrb_PauseMusicStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); + +PauseMusicStream(*parameter_music); +return mrb_nil_value(); +} + +//void PauseSound +static mrb_value +mrb_PauseSound(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); + +PauseSound(*parameter_sound); +return mrb_nil_value(); +} + +//void PlayAudioStream +static mrb_value +mrb_PlayAudioStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); + +PlayAudioStream(*parameter_stream); +return mrb_nil_value(); +} + +//void PlayMusicStream +static mrb_value +mrb_PlayMusicStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); + +PlayMusicStream(*parameter_music); +return mrb_nil_value(); +} + +//void PlaySound +static mrb_value +mrb_PlaySound(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); + +PlaySound(*parameter_sound); +return mrb_nil_value(); +} + +//void PlaySoundMulti +static mrb_value +mrb_PlaySoundMulti(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); + +PlaySoundMulti(*parameter_sound); +return mrb_nil_value(); +} + +//void PollInputEvents +static mrb_value +mrb_PollInputEvents(mrb_state* mrb, mrb_value self) { + +PollInputEvents(); +return mrb_nil_value(); +} + +//void RestoreWindow +static mrb_value +mrb_RestoreWindow(mrb_state* mrb, mrb_value self) { + +RestoreWindow(); +return mrb_nil_value(); +} + +//void ResumeAudioStream +static mrb_value +mrb_ResumeAudioStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); + +ResumeAudioStream(*parameter_stream); +return mrb_nil_value(); +} + +//void ResumeMusicStream +static mrb_value +mrb_ResumeMusicStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); + +ResumeMusicStream(*parameter_music); +return mrb_nil_value(); +} + +//void ResumeSound +static mrb_value +mrb_ResumeSound(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); + +ResumeSound(*parameter_sound); +return mrb_nil_value(); +} + +//bool SaveFileText +static mrb_value +mrb_SaveFileText(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; +char * parameter_text; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "fileName"), +mrb_intern_lit(mrb, "text") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_fileName = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_SaveFileText; + +return_of_SaveFileText = SaveFileText(parameter_fileName, parameter_text); +return mrb_bool_value(return_of_SaveFileText); +} + +//bool SaveStorageValue +static mrb_value +mrb_SaveStorageValue(mrb_state* mrb, mrb_value self) { +int parameter_position; +int parameter_value; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "value") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_value = mrb_as_int(mrb, kw_values[1]); +} + +bool return_of_SaveStorageValue; + +return_of_SaveStorageValue = SaveStorageValue(parameter_position, parameter_value); +return mrb_bool_value(return_of_SaveStorageValue); +} + +//void SeekMusicStream +static mrb_value +mrb_SeekMusicStream(mrb_state* mrb, mrb_value self) { +Music *parameter_music; +float parameter_position; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "music"), +mrb_intern_lit(mrb, "position") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_music = DATA_GET_PTR(mrb, kw_values[0], &mrb_Music_struct, Music); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = mrb_as_float(mrb, kw_values[1]); +} + + +SeekMusicStream(*parameter_music, parameter_position); +return mrb_nil_value(); +} + +//void SetAudioStreamBufferSizeDefault +static mrb_value +mrb_SetAudioStreamBufferSizeDefault(mrb_state* mrb, mrb_value self) { +mrb_int parameter_size; + +mrb_get_args(mrb, "i", ¶meter_size); + +SetAudioStreamBufferSizeDefault(parameter_size); +return mrb_nil_value(); +} + +//void SetAudioStreamPan +static mrb_value +mrb_SetAudioStreamPan(mrb_state* mrb, mrb_value self) { +AudioStream *parameter_stream; +float parameter_pan; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "stream"), +mrb_intern_lit(mrb, "pan") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_stream = DATA_GET_PTR(mrb, kw_values[0], &mrb_AudioStream_struct, AudioStream); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pan = mrb_as_float(mrb, kw_values[1]); +} + + +SetAudioStreamPan(*parameter_stream, parameter_pan); +return mrb_nil_value(); +} + +//void SetAudioStreamPitch +static mrb_value +mrb_SetAudioStreamPitch(mrb_state* mrb, mrb_value self) { +AudioStream *parameter_stream; +float parameter_pitch; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "stream"), +mrb_intern_lit(mrb, "pitch") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_stream = DATA_GET_PTR(mrb, kw_values[0], &mrb_AudioStream_struct, AudioStream); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pitch = mrb_as_float(mrb, kw_values[1]); +} + + +SetAudioStreamPitch(*parameter_stream, parameter_pitch); +return mrb_nil_value(); +} + +//void SetAudioStreamVolume +static mrb_value +mrb_SetAudioStreamVolume(mrb_state* mrb, mrb_value self) { +AudioStream *parameter_stream; +float parameter_volume; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "stream"), +mrb_intern_lit(mrb, "volume") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_stream = DATA_GET_PTR(mrb, kw_values[0], &mrb_AudioStream_struct, AudioStream); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_volume = mrb_as_float(mrb, kw_values[1]); +} + + +SetAudioStreamVolume(*parameter_stream, parameter_volume); +return mrb_nil_value(); +} + +//void SetCameraAltControl +static mrb_value +mrb_SetCameraAltControl(mrb_state* mrb, mrb_value self) { +mrb_int parameter_keyAlt; + +mrb_get_args(mrb, "i", ¶meter_keyAlt); + +SetCameraAltControl(parameter_keyAlt); +return mrb_nil_value(); +} + +//void SetCameraMoveControls +static mrb_value +mrb_SetCameraMoveControls(mrb_state* mrb, mrb_value self) { +int parameter_keyFront; +int parameter_keyBack; +int parameter_keyRight; +int parameter_keyLeft; +int parameter_keyUp; +int parameter_keyDown; + +uint32_t kw_num = 6; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "keyFront"), +mrb_intern_lit(mrb, "keyBack"), +mrb_intern_lit(mrb, "keyRight"), +mrb_intern_lit(mrb, "keyLeft"), +mrb_intern_lit(mrb, "keyUp"), +mrb_intern_lit(mrb, "keyDown") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_keyFront = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_keyBack = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_keyRight = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_keyLeft = mrb_as_int(mrb, kw_values[3]); +} + +if (mrb_undef_p(kw_values[4])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_keyUp = mrb_as_int(mrb, kw_values[4]); +} + +if (mrb_undef_p(kw_values[5])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_keyDown = mrb_as_int(mrb, kw_values[5]); +} + + +SetCameraMoveControls(parameter_keyFront, parameter_keyBack, parameter_keyRight, parameter_keyLeft, parameter_keyUp, parameter_keyDown); +return mrb_nil_value(); +} + +//void SetCameraPanControl +static mrb_value +mrb_SetCameraPanControl(mrb_state* mrb, mrb_value self) { +mrb_int parameter_keyPan; + +mrb_get_args(mrb, "i", ¶meter_keyPan); + +SetCameraPanControl(parameter_keyPan); +return mrb_nil_value(); +} + +//void SetCameraSmoothZoomControl +static mrb_value +mrb_SetCameraSmoothZoomControl(mrb_state* mrb, mrb_value self) { +mrb_int parameter_keySmoothZoom; + +mrb_get_args(mrb, "i", ¶meter_keySmoothZoom); + +SetCameraSmoothZoomControl(parameter_keySmoothZoom); +return mrb_nil_value(); +} + +//void SetClipboardText +static mrb_value +mrb_SetClipboardText(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); + +SetClipboardText(parameter_text); +return mrb_nil_value(); +} + +//void SetConfigFlags +static mrb_value +mrb_SetConfigFlags(mrb_state* mrb, mrb_value self) { +mrb_int parameter_flags; + +mrb_get_args(mrb, "i", ¶meter_flags); + +SetConfigFlags(parameter_flags); +return mrb_nil_value(); +} + +//void SetExitKey +static mrb_value +mrb_SetExitKey(mrb_state* mrb, mrb_value self) { +mrb_int parameter_key; + +mrb_get_args(mrb, "i", ¶meter_key); + +SetExitKey(parameter_key); +return mrb_nil_value(); +} + +//int SetGamepadMappings +static mrb_value +mrb_SetGamepadMappings(mrb_state* mrb, mrb_value self) { +char * parameter_mappings; + +mrb_get_args(mrb, "z", ¶meter_mappings); +int return_of_SetGamepadMappings; + +return_of_SetGamepadMappings = SetGamepadMappings(parameter_mappings); +return mrb_fixnum_value(return_of_SetGamepadMappings); +} + +//void SetGesturesEnabled +static mrb_value +mrb_SetGesturesEnabled(mrb_state* mrb, mrb_value self) { +mrb_int parameter_flags; + +mrb_get_args(mrb, "i", ¶meter_flags); + +SetGesturesEnabled(parameter_flags); +return mrb_nil_value(); +} + +//void SetMasterVolume +static mrb_value +mrb_SetMasterVolume(mrb_state* mrb, mrb_value self) { +mrb_float parameter_volume; + +mrb_get_args(mrb, "f", ¶meter_volume); + +SetMasterVolume(parameter_volume); +return mrb_nil_value(); +} + +//void SetMaterialTexture +static mrb_value +mrb_SetMaterialTexture(mrb_state* mrb, mrb_value self) { +Material *parameter_material; +int parameter_mapType; +Texture *parameter_texture; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "material"), +mrb_intern_lit(mrb, "mapType"), +mrb_intern_lit(mrb, "texture") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_material = DATA_GET_PTR(mrb, kw_values[0], &mrb_Material_struct, Material); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_mapType = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[2], &mrb_Texture_struct, Texture); + +} + + +SetMaterialTexture(parameter_material, parameter_mapType, *parameter_texture); +return mrb_nil_value(); +} + +//void SetModelMeshMaterial +static mrb_value +mrb_SetModelMeshMaterial(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +int parameter_meshId; +int parameter_materialId; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "meshId"), +mrb_intern_lit(mrb, "materialId") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_meshId = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_materialId = mrb_as_int(mrb, kw_values[2]); +} + + +SetModelMeshMaterial(parameter_model, parameter_meshId, parameter_materialId); +return mrb_nil_value(); +} + +//void SetMouseCursor +static mrb_value +mrb_SetMouseCursor(mrb_state* mrb, mrb_value self) { +mrb_int parameter_cursor; + +mrb_get_args(mrb, "i", ¶meter_cursor); + +SetMouseCursor(parameter_cursor); +return mrb_nil_value(); +} + +//void SetMouseOffset +static mrb_value +mrb_SetMouseOffset(mrb_state* mrb, mrb_value self) { +int parameter_offsetX; +int parameter_offsetY; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "offsetX"), +mrb_intern_lit(mrb, "offsetY") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_offsetX = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_offsetY = mrb_as_int(mrb, kw_values[1]); +} + + +SetMouseOffset(parameter_offsetX, parameter_offsetY); +return mrb_nil_value(); +} + +//void SetMousePosition +static mrb_value +mrb_SetMousePosition(mrb_state* mrb, mrb_value self) { +int parameter_x; +int parameter_y; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_x = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_y = mrb_as_int(mrb, kw_values[1]); +} + + +SetMousePosition(parameter_x, parameter_y); +return mrb_nil_value(); +} + +//void SetMouseScale +static mrb_value +mrb_SetMouseScale(mrb_state* mrb, mrb_value self) { +float parameter_scaleX; +float parameter_scaleY; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "scaleX"), +mrb_intern_lit(mrb, "scaleY") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scaleX = mrb_as_float(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_scaleY = mrb_as_float(mrb, kw_values[1]); +} + + +SetMouseScale(parameter_scaleX, parameter_scaleY); +return mrb_nil_value(); +} + +//void SetMusicPan +static mrb_value +mrb_SetMusicPan(mrb_state* mrb, mrb_value self) { +Music *parameter_music; +float parameter_pan; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "music"), +mrb_intern_lit(mrb, "pan") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_music = DATA_GET_PTR(mrb, kw_values[0], &mrb_Music_struct, Music); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pan = mrb_as_float(mrb, kw_values[1]); +} + + +SetMusicPan(*parameter_music, parameter_pan); +return mrb_nil_value(); +} + +//void SetMusicPitch +static mrb_value +mrb_SetMusicPitch(mrb_state* mrb, mrb_value self) { +Music *parameter_music; +float parameter_pitch; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "music"), +mrb_intern_lit(mrb, "pitch") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_music = DATA_GET_PTR(mrb, kw_values[0], &mrb_Music_struct, Music); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pitch = mrb_as_float(mrb, kw_values[1]); +} + + +SetMusicPitch(*parameter_music, parameter_pitch); +return mrb_nil_value(); +} + +//void SetMusicVolume +static mrb_value +mrb_SetMusicVolume(mrb_state* mrb, mrb_value self) { +Music *parameter_music; +float parameter_volume; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "music"), +mrb_intern_lit(mrb, "volume") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_music = DATA_GET_PTR(mrb, kw_values[0], &mrb_Music_struct, Music); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_volume = mrb_as_float(mrb, kw_values[1]); +} + + +SetMusicVolume(*parameter_music, parameter_volume); +return mrb_nil_value(); +} + +//void SetRandomSeed +static mrb_value +mrb_SetRandomSeed(mrb_state* mrb, mrb_value self) { +mrb_int parameter_seed; + +mrb_get_args(mrb, "i", ¶meter_seed); + +SetRandomSeed(parameter_seed); +return mrb_nil_value(); +} + +//void SetShaderValueMatrix +static mrb_value +mrb_SetShaderValueMatrix(mrb_state* mrb, mrb_value self) { +Shader *parameter_shader; +int parameter_locIndex; +Matrix *parameter_mat; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "shader"), +mrb_intern_lit(mrb, "locIndex"), +mrb_intern_lit(mrb, "mat") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_shader = DATA_GET_PTR(mrb, kw_values[0], &mrb_Shader_struct, Shader); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_locIndex = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_mat = DATA_GET_PTR(mrb, kw_values[2], &mrb_Matrix_struct, Matrix); + +} + + +SetShaderValueMatrix(*parameter_shader, parameter_locIndex, *parameter_mat); +return mrb_nil_value(); +} + +//void SetShaderValueTexture +static mrb_value +mrb_SetShaderValueTexture(mrb_state* mrb, mrb_value self) { +Shader *parameter_shader; +int parameter_locIndex; +Texture *parameter_texture; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "shader"), +mrb_intern_lit(mrb, "locIndex"), +mrb_intern_lit(mrb, "texture") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_shader = DATA_GET_PTR(mrb, kw_values[0], &mrb_Shader_struct, Shader); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_locIndex = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[2], &mrb_Texture_struct, Texture); + +} + + +SetShaderValueTexture(*parameter_shader, parameter_locIndex, *parameter_texture); +return mrb_nil_value(); +} + +//void SetShapesTexture +static mrb_value +mrb_SetShapesTexture(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +Rectangle *parameter_source; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "source") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_source = DATA_GET_PTR(mrb, kw_values[1], &mrb_Rectangle_struct, Rectangle); + +} + + +SetShapesTexture(*parameter_texture, *parameter_source); +return mrb_nil_value(); +} + +//void SetSoundPan +static mrb_value +mrb_SetSoundPan(mrb_state* mrb, mrb_value self) { +Sound *parameter_sound; +float parameter_pan; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "sound"), +mrb_intern_lit(mrb, "pan") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sound = DATA_GET_PTR(mrb, kw_values[0], &mrb_Sound_struct, Sound); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pan = mrb_as_float(mrb, kw_values[1]); +} + + +SetSoundPan(*parameter_sound, parameter_pan); +return mrb_nil_value(); +} + +//void SetSoundPitch +static mrb_value +mrb_SetSoundPitch(mrb_state* mrb, mrb_value self) { +Sound *parameter_sound; +float parameter_pitch; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "sound"), +mrb_intern_lit(mrb, "pitch") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sound = DATA_GET_PTR(mrb, kw_values[0], &mrb_Sound_struct, Sound); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_pitch = mrb_as_float(mrb, kw_values[1]); +} + + +SetSoundPitch(*parameter_sound, parameter_pitch); +return mrb_nil_value(); +} + +//void SetSoundVolume +static mrb_value +mrb_SetSoundVolume(mrb_state* mrb, mrb_value self) { +Sound *parameter_sound; +float parameter_volume; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "sound"), +mrb_intern_lit(mrb, "volume") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sound = DATA_GET_PTR(mrb, kw_values[0], &mrb_Sound_struct, Sound); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_volume = mrb_as_float(mrb, kw_values[1]); +} + + +SetSoundVolume(*parameter_sound, parameter_volume); +return mrb_nil_value(); +} + +//void SetTargetFPS +static mrb_value +mrb_SetTargetFPS(mrb_state* mrb, mrb_value self) { +mrb_int parameter_fps; + +mrb_get_args(mrb, "i", ¶meter_fps); + +SetTargetFPS(parameter_fps); +return mrb_nil_value(); +} + +//void SetTextureFilter +static mrb_value +mrb_SetTextureFilter(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +int parameter_filter; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "filter") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_filter = mrb_as_int(mrb, kw_values[1]); +} + + +SetTextureFilter(*parameter_texture, parameter_filter); +return mrb_nil_value(); +} + +//void SetTextureWrap +static mrb_value +mrb_SetTextureWrap(mrb_state* mrb, mrb_value self) { +Texture *parameter_texture; +int parameter_wrap; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "texture"), +mrb_intern_lit(mrb, "wrap") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_texture = DATA_GET_PTR(mrb, kw_values[0], &mrb_Texture_struct, Texture); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_wrap = mrb_as_int(mrb, kw_values[1]); +} + + +SetTextureWrap(*parameter_texture, parameter_wrap); +return mrb_nil_value(); +} + +//void SetTraceLogLevel +static mrb_value +mrb_SetTraceLogLevel(mrb_state* mrb, mrb_value self) { +mrb_int parameter_logLevel; + +mrb_get_args(mrb, "i", ¶meter_logLevel); + +SetTraceLogLevel(parameter_logLevel); +return mrb_nil_value(); +} + +//void SetWindowIcon +static mrb_value +mrb_SetWindowIcon(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +SetWindowIcon(*parameter_image); +return mrb_nil_value(); +} + +//void SetWindowMinSize +static mrb_value +mrb_SetWindowMinSize(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + + +SetWindowMinSize(parameter_width, parameter_height); +return mrb_nil_value(); +} + +//void SetWindowMonitor +static mrb_value +mrb_SetWindowMonitor(mrb_state* mrb, mrb_value self) { +mrb_int parameter_monitor; + +mrb_get_args(mrb, "i", ¶meter_monitor); + +SetWindowMonitor(parameter_monitor); +return mrb_nil_value(); +} + +//void SetWindowOpacity +static mrb_value +mrb_SetWindowOpacity(mrb_state* mrb, mrb_value self) { +mrb_float parameter_opacity; + +mrb_get_args(mrb, "f", ¶meter_opacity); + +SetWindowOpacity(parameter_opacity); +return mrb_nil_value(); +} + +//void SetWindowPosition +static mrb_value +mrb_SetWindowPosition(mrb_state* mrb, mrb_value self) { +int parameter_x; +int parameter_y; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "x"), +mrb_intern_lit(mrb, "y") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_x = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_y = mrb_as_int(mrb, kw_values[1]); +} + + +SetWindowPosition(parameter_x, parameter_y); +return mrb_nil_value(); +} + +//void SetWindowSize +static mrb_value +mrb_SetWindowSize(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + + +SetWindowSize(parameter_width, parameter_height); +return mrb_nil_value(); +} + +//void SetWindowState +static mrb_value +mrb_SetWindowState(mrb_state* mrb, mrb_value self) { +mrb_int parameter_flags; + +mrb_get_args(mrb, "i", ¶meter_flags); + +SetWindowState(parameter_flags); +return mrb_nil_value(); +} + +//void SetWindowTitle +static mrb_value +mrb_SetWindowTitle(mrb_state* mrb, mrb_value self) { +char * parameter_title; + +mrb_get_args(mrb, "z", ¶meter_title); + +SetWindowTitle(parameter_title); +return mrb_nil_value(); +} + +//void ShowCursor +static mrb_value +mrb_ShowCursor(mrb_state* mrb, mrb_value self) { + +ShowCursor(); +return mrb_nil_value(); +} + +//void StopAudioStream +static mrb_value +mrb_StopAudioStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); + +StopAudioStream(*parameter_stream); +return mrb_nil_value(); +} + +//void StopMusicStream +static mrb_value +mrb_StopMusicStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); + +StopMusicStream(*parameter_music); +return mrb_nil_value(); +} + +//void StopSound +static mrb_value +mrb_StopSound(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); + +StopSound(*parameter_sound); +return mrb_nil_value(); +} + +//void StopSoundMulti +static mrb_value +mrb_StopSoundMulti(mrb_state* mrb, mrb_value self) { + +StopSoundMulti(); +return mrb_nil_value(); +} + +//void SwapScreenBuffer +static mrb_value +mrb_SwapScreenBuffer(mrb_state* mrb, mrb_value self) { + +SwapScreenBuffer(); +return mrb_nil_value(); +} + +//void TakeScreenshot +static mrb_value +mrb_TakeScreenshot(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); + +TakeScreenshot(parameter_fileName); +return mrb_nil_value(); +} + +//void TextAppend +static mrb_value +mrb_TextAppend(mrb_state* mrb, mrb_value self) { +char * parameter_text; +char * parameter_append; +int parameter_position; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "append"), +mrb_intern_lit(mrb, "position") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_append = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = mrb_as_int(mrb, kw_values[2]); +} + + +TextAppend(parameter_text, parameter_append, (int *)¶meter_position); +return mrb_nil_value(); +} + +//int TextCopy +static mrb_value +mrb_TextCopy(mrb_state* mrb, mrb_value self) { +char * parameter_dst; +char * parameter_src; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "dst"), +mrb_intern_lit(mrb, "src") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dst = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_src = mrb_str_to_cstr(mrb, kw_values[1]); +} + +int return_of_TextCopy; + +return_of_TextCopy = TextCopy(parameter_dst, parameter_src); +return mrb_fixnum_value(return_of_TextCopy); +} + +//int TextFindIndex +static mrb_value +mrb_TextFindIndex(mrb_state* mrb, mrb_value self) { +char * parameter_text; +char * parameter_find; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "find") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_find = mrb_str_to_cstr(mrb, kw_values[1]); +} + +int return_of_TextFindIndex; + +return_of_TextFindIndex = TextFindIndex(parameter_text, parameter_find); +return mrb_fixnum_value(return_of_TextFindIndex); +} + +//char * TextInsert +static mrb_value +mrb_TextInsert(mrb_state* mrb, mrb_value self) { +char * parameter_text; +char * parameter_insert; +int parameter_position; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "insert"), +mrb_intern_lit(mrb, "position") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_insert = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = mrb_as_int(mrb, kw_values[2]); +} + +char * return_of_TextInsert; + +return_of_TextInsert = TextInsert(parameter_text, parameter_insert, parameter_position); +return mrb_str_new_cstr(mrb, return_of_TextInsert); +} + +//bool TextIsEqual +static mrb_value +mrb_TextIsEqual(mrb_state* mrb, mrb_value self) { +char * parameter_text1; +char * parameter_text2; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text1"), +mrb_intern_lit(mrb, "text2") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text1 = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text2 = mrb_str_to_cstr(mrb, kw_values[1]); +} + +bool return_of_TextIsEqual; + +return_of_TextIsEqual = TextIsEqual(parameter_text1, parameter_text2); +return mrb_bool_value(return_of_TextIsEqual); +} + +//unsigned int TextLength +static mrb_value +mrb_TextLength(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); +unsigned int return_of_TextLength; + +return_of_TextLength = TextLength(parameter_text); +return mrb_fixnum_value(return_of_TextLength); +} + +//char * TextReplace +static mrb_value +mrb_TextReplace(mrb_state* mrb, mrb_value self) { +char * parameter_text; +char * parameter_replace; +char * parameter_by; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "replace"), +mrb_intern_lit(mrb, "by") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_replace = mrb_str_to_cstr(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_by = mrb_str_to_cstr(mrb, kw_values[2]); +} + +char * return_of_TextReplace; + +return_of_TextReplace = TextReplace(parameter_text, parameter_replace, parameter_by); +return mrb_str_new_cstr(mrb, return_of_TextReplace); +} + +//const char * TextSubtext +static mrb_value +mrb_TextSubtext(mrb_state* mrb, mrb_value self) { +char * parameter_text; +int parameter_position; +int parameter_length; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "text"), +mrb_intern_lit(mrb, "position"), +mrb_intern_lit(mrb, "length") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_text = mrb_str_to_cstr(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_position = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_length = mrb_as_int(mrb, kw_values[2]); +} + +const char * return_of_TextSubtext; + +return_of_TextSubtext = TextSubtext(parameter_text, parameter_position, parameter_length); +return mrb_str_new_cstr(mrb, return_of_TextSubtext); +} + +//int TextToInteger +static mrb_value +mrb_TextToInteger(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); +int return_of_TextToInteger; + +return_of_TextToInteger = TextToInteger(parameter_text); +return mrb_fixnum_value(return_of_TextToInteger); +} + +//const char * TextToLower +static mrb_value +mrb_TextToLower(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); +const char * return_of_TextToLower; + +return_of_TextToLower = TextToLower(parameter_text); +return mrb_str_new_cstr(mrb, return_of_TextToLower); +} + +//const char * TextToPascal +static mrb_value +mrb_TextToPascal(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); +const char * return_of_TextToPascal; + +return_of_TextToPascal = TextToPascal(parameter_text); +return mrb_str_new_cstr(mrb, return_of_TextToPascal); +} + +//const char * TextToUpper +static mrb_value +mrb_TextToUpper(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); +const char * return_of_TextToUpper; + +return_of_TextToUpper = TextToUpper(parameter_text); +return mrb_str_new_cstr(mrb, return_of_TextToUpper); +} + +//void ToggleFullscreen +static mrb_value +mrb_ToggleFullscreen(mrb_state* mrb, mrb_value self) { + +ToggleFullscreen(); +return mrb_nil_value(); +} + +//void UnloadAudioStream +static mrb_value +mrb_UnloadAudioStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_stream; + +mrb_get_args(mrb, "o", ¶meter_mrb_stream); +AudioStream *parameter_stream; +parameter_stream = DATA_GET_PTR(mrb, parameter_mrb_stream, &mrb_AudioStream_struct, AudioStream); + +UnloadAudioStream(*parameter_stream); +return mrb_nil_value(); +} + +//void UnloadCodepoints +static mrb_value +mrb_UnloadCodepoints(mrb_state* mrb, mrb_value self) { +mrb_int parameter_codepoints; + +mrb_get_args(mrb, "i", ¶meter_codepoints); + +UnloadCodepoints((int *)¶meter_codepoints); +return mrb_nil_value(); +} + +//void UnloadFileData +static mrb_value +mrb_UnloadFileData(mrb_state* mrb, mrb_value self) { +mrb_int parameter_data; + +mrb_get_args(mrb, "i", ¶meter_data); + +UnloadFileData((unsigned char *)¶meter_data); +return mrb_nil_value(); +} + +//void UnloadFileText +static mrb_value +mrb_UnloadFileText(mrb_state* mrb, mrb_value self) { +char * parameter_text; + +mrb_get_args(mrb, "z", ¶meter_text); + +UnloadFileText(parameter_text); +return mrb_nil_value(); +} + +//void UnloadFont +static mrb_value +mrb_UnloadFont(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_font; + +mrb_get_args(mrb, "o", ¶meter_mrb_font); +Font *parameter_font; +parameter_font = DATA_GET_PTR(mrb, parameter_mrb_font, &mrb_Font_struct, Font); + +UnloadFont(*parameter_font); +return mrb_nil_value(); +} + +//void UnloadFontData +static mrb_value +mrb_UnloadFontData(mrb_state* mrb, mrb_value self) { +GlyphInfo *parameter_chars; +int parameter_glyphCount; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "chars"), +mrb_intern_lit(mrb, "glyphCount") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_chars = DATA_GET_PTR(mrb, kw_values[0], &mrb_GlyphInfo_struct, GlyphInfo); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_glyphCount = mrb_as_int(mrb, kw_values[1]); +} + + +UnloadFontData(parameter_chars, parameter_glyphCount); +return mrb_nil_value(); +} + +//void UnloadImage +static mrb_value +mrb_UnloadImage(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); + +UnloadImage(*parameter_image); +return mrb_nil_value(); +} + +//void UnloadImageColors +static mrb_value +mrb_UnloadImageColors(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_colors; + +mrb_get_args(mrb, "o", ¶meter_mrb_colors); +Color *parameter_colors; +parameter_colors = DATA_GET_PTR(mrb, parameter_mrb_colors, &mrb_Color_struct, Color); + +UnloadImageColors(parameter_colors); +return mrb_nil_value(); +} + +//void UnloadImagePalette +static mrb_value +mrb_UnloadImagePalette(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_colors; + +mrb_get_args(mrb, "o", ¶meter_mrb_colors); +Color *parameter_colors; +parameter_colors = DATA_GET_PTR(mrb, parameter_mrb_colors, &mrb_Color_struct, Color); + +UnloadImagePalette(parameter_colors); +return mrb_nil_value(); +} + +//void UnloadMaterial +static mrb_value +mrb_UnloadMaterial(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_material; + +mrb_get_args(mrb, "o", ¶meter_mrb_material); +Material *parameter_material; +parameter_material = DATA_GET_PTR(mrb, parameter_mrb_material, &mrb_Material_struct, Material); + +UnloadMaterial(*parameter_material); +return mrb_nil_value(); +} + +//void UnloadMesh +static mrb_value +mrb_UnloadMesh(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_mesh; + +mrb_get_args(mrb, "o", ¶meter_mrb_mesh); +Mesh *parameter_mesh; +parameter_mesh = DATA_GET_PTR(mrb, parameter_mrb_mesh, &mrb_Mesh_struct, Mesh); + +UnloadMesh(*parameter_mesh); +return mrb_nil_value(); +} + +//void UnloadModel +static mrb_value +mrb_UnloadModel(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_model; + +mrb_get_args(mrb, "o", ¶meter_mrb_model); +Model *parameter_model; +parameter_model = DATA_GET_PTR(mrb, parameter_mrb_model, &mrb_Model_struct, Model); + +UnloadModel(*parameter_model); +return mrb_nil_value(); +} + +//void UnloadModelAnimation +static mrb_value +mrb_UnloadModelAnimation(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_anim; + +mrb_get_args(mrb, "o", ¶meter_mrb_anim); +ModelAnimation *parameter_anim; +parameter_anim = DATA_GET_PTR(mrb, parameter_mrb_anim, &mrb_ModelAnimation_struct, ModelAnimation); + +UnloadModelAnimation(*parameter_anim); +return mrb_nil_value(); +} + +//void UnloadModelAnimations +static mrb_value +mrb_UnloadModelAnimations(mrb_state* mrb, mrb_value self) { +ModelAnimation *parameter_animations; +int parameter_count; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "animations"), +mrb_intern_lit(mrb, "count") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_animations = DATA_GET_PTR(mrb, kw_values[0], &mrb_ModelAnimation_struct, ModelAnimation); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_count = mrb_as_int(mrb, kw_values[1]); +} + + +UnloadModelAnimations(parameter_animations, parameter_count); +return mrb_nil_value(); +} + +//void UnloadModelKeepMeshes +static mrb_value +mrb_UnloadModelKeepMeshes(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_model; + +mrb_get_args(mrb, "o", ¶meter_mrb_model); +Model *parameter_model; +parameter_model = DATA_GET_PTR(mrb, parameter_mrb_model, &mrb_Model_struct, Model); + +UnloadModelKeepMeshes(*parameter_model); +return mrb_nil_value(); +} + +//void UnloadMusicStream +static mrb_value +mrb_UnloadMusicStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); + +UnloadMusicStream(*parameter_music); +return mrb_nil_value(); +} + +//void UnloadRenderTexture +static mrb_value +mrb_UnloadRenderTexture(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_target; + +mrb_get_args(mrb, "o", ¶meter_mrb_target); +RenderTexture *parameter_target; +parameter_target = DATA_GET_PTR(mrb, parameter_mrb_target, &mrb_RenderTexture_struct, RenderTexture); + +UnloadRenderTexture(*parameter_target); +return mrb_nil_value(); +} + +//void UnloadShader +static mrb_value +mrb_UnloadShader(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_shader; + +mrb_get_args(mrb, "o", ¶meter_mrb_shader); +Shader *parameter_shader; +parameter_shader = DATA_GET_PTR(mrb, parameter_mrb_shader, &mrb_Shader_struct, Shader); + +UnloadShader(*parameter_shader); +return mrb_nil_value(); +} + +//void UnloadSound +static mrb_value +mrb_UnloadSound(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_sound; + +mrb_get_args(mrb, "o", ¶meter_mrb_sound); +Sound *parameter_sound; +parameter_sound = DATA_GET_PTR(mrb, parameter_mrb_sound, &mrb_Sound_struct, Sound); + +UnloadSound(*parameter_sound); +return mrb_nil_value(); +} + +//void UnloadTexture +static mrb_value +mrb_UnloadTexture(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_texture; + +mrb_get_args(mrb, "o", ¶meter_mrb_texture); +Texture *parameter_texture; +parameter_texture = DATA_GET_PTR(mrb, parameter_mrb_texture, &mrb_Texture_struct, Texture); + +UnloadTexture(*parameter_texture); +return mrb_nil_value(); +} + +//void UnloadVrStereoConfig +static mrb_value +mrb_UnloadVrStereoConfig(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_config; + +mrb_get_args(mrb, "o", ¶meter_mrb_config); +VrStereoConfig *parameter_config; +parameter_config = DATA_GET_PTR(mrb, parameter_mrb_config, &mrb_VrStereoConfig_struct, VrStereoConfig); + +UnloadVrStereoConfig(*parameter_config); +return mrb_nil_value(); +} + +//void UnloadWave +static mrb_value +mrb_UnloadWave(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_wave; + +mrb_get_args(mrb, "o", ¶meter_mrb_wave); +Wave *parameter_wave; +parameter_wave = DATA_GET_PTR(mrb, parameter_mrb_wave, &mrb_Wave_struct, Wave); + +UnloadWave(*parameter_wave); +return mrb_nil_value(); +} + +//void UnloadWaveSamples +static mrb_value +mrb_UnloadWaveSamples(mrb_state* mrb, mrb_value self) { +mrb_float parameter_samples; + +mrb_get_args(mrb, "f", ¶meter_samples); + +UnloadWaveSamples((float *)¶meter_samples); +return mrb_nil_value(); +} + +//void UpdateModelAnimation +static mrb_value +mrb_UpdateModelAnimation(mrb_state* mrb, mrb_value self) { +Model *parameter_model; +ModelAnimation *parameter_anim; +int parameter_frame; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "model"), +mrb_intern_lit(mrb, "anim"), +mrb_intern_lit(mrb, "frame") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_model = DATA_GET_PTR(mrb, kw_values[0], &mrb_Model_struct, Model); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_anim = DATA_GET_PTR(mrb, kw_values[1], &mrb_ModelAnimation_struct, ModelAnimation); + +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_frame = mrb_as_int(mrb, kw_values[2]); +} + + +UpdateModelAnimation(*parameter_model, *parameter_anim, parameter_frame); +return mrb_nil_value(); +} + +//void UpdateMusicStream +static mrb_value +mrb_UpdateMusicStream(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_music; + +mrb_get_args(mrb, "o", ¶meter_mrb_music); +Music *parameter_music; +parameter_music = DATA_GET_PTR(mrb, parameter_mrb_music, &mrb_Music_struct, Music); + +UpdateMusicStream(*parameter_music); +return mrb_nil_value(); +} + +//void UploadMesh +static mrb_value +mrb_UploadMesh(mrb_state* mrb, mrb_value self) { +Mesh *parameter_mesh; +bool parameter_dynamic; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "mesh"), +mrb_intern_lit(mrb, "dynamic") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_mesh = DATA_GET_PTR(mrb, kw_values[0], &mrb_Mesh_struct, Mesh); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_dynamic = mrb_as_int(mrb, kw_values[1]); +} + + +UploadMesh(parameter_mesh, parameter_dynamic); +return mrb_nil_value(); +} + +//void WaitTime +static mrb_value +mrb_WaitTime(mrb_state* mrb, mrb_value self) { +mrb_float parameter_ms; + +mrb_get_args(mrb, "f", ¶meter_ms); + +WaitTime(parameter_ms); +return mrb_nil_value(); +} + +//Wave WaveCopy +static mrb_value +mrb_WaveCopy(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_wave; + +mrb_get_args(mrb, "o", ¶meter_mrb_wave); +Wave *parameter_wave; +parameter_wave = DATA_GET_PTR(mrb, parameter_mrb_wave, &mrb_Wave_struct, Wave); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *wave_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Wave_struct.struct_name); +Wave *return_of_WaveCopy = (Wave *)mrb_malloc(mrb, sizeof(Wave)); + +*return_of_WaveCopy = WaveCopy(*parameter_wave); +return mrb_obj_value(Data_Wrap_Struct(mrb, wave_mrb_class, &mrb_Wave_struct, return_of_WaveCopy)); +} + +//void WaveCrop +static mrb_value +mrb_WaveCrop(mrb_state* mrb, mrb_value self) { +Wave *parameter_wave; +int parameter_initSample; +int parameter_finalSample; + +uint32_t kw_num = 3; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "wave"), +mrb_intern_lit(mrb, "initSample"), +mrb_intern_lit(mrb, "finalSample") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_wave = DATA_GET_PTR(mrb, kw_values[0], &mrb_Wave_struct, Wave); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_initSample = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_finalSample = mrb_as_int(mrb, kw_values[2]); +} + + +WaveCrop(parameter_wave, parameter_initSample, parameter_finalSample); +return mrb_nil_value(); +} + +//void WaveFormat +static mrb_value +mrb_WaveFormat(mrb_state* mrb, mrb_value self) { +Wave *parameter_wave; +int parameter_sampleRate; +int parameter_sampleSize; +int parameter_channels; + +uint32_t kw_num = 4; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "wave"), +mrb_intern_lit(mrb, "sampleRate"), +mrb_intern_lit(mrb, "sampleSize"), +mrb_intern_lit(mrb, "channels") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_wave = DATA_GET_PTR(mrb, kw_values[0], &mrb_Wave_struct, Wave); + +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sampleRate = mrb_as_int(mrb, kw_values[1]); +} + +if (mrb_undef_p(kw_values[2])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_sampleSize = mrb_as_int(mrb, kw_values[2]); +} + +if (mrb_undef_p(kw_values[3])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_channels = mrb_as_int(mrb, kw_values[3]); +} + + +WaveFormat(parameter_wave, parameter_sampleRate, parameter_sampleSize, parameter_channels); +return mrb_nil_value(); +} + +//bool WindowShouldClose +static mrb_value +mrb_WindowShouldClose(mrb_state* mrb, mrb_value self) { +bool return_of_WindowShouldClose; + +return_of_WindowShouldClose = WindowShouldClose(); +return mrb_bool_value(return_of_WindowShouldClose); +} + +//RenderTexture LoadRenderTexture +static mrb_value +mrb_LoadRenderTexture(mrb_state* mrb, mrb_value self) { +int parameter_width; +int parameter_height; + +uint32_t kw_num = 2; +const mrb_sym kw_names[] = { +mrb_intern_lit(mrb, "width"), +mrb_intern_lit(mrb, "height") +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + +if (mrb_undef_p(kw_values[0])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_width = mrb_as_int(mrb, kw_values[0]); +} + +if (mrb_undef_p(kw_values[1])) { +mrb_load_string(mrb, "raise ArgumentError.new \"Missing Keyword Argument\""); +} else { +parameter_height = mrb_as_int(mrb, kw_values[1]); +} + +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *rendertexture_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_RenderTexture_struct.struct_name); +RenderTexture *return_of_LoadRenderTexture = (RenderTexture *)mrb_malloc(mrb, sizeof(RenderTexture)); + +*return_of_LoadRenderTexture = LoadRenderTexture(parameter_width, parameter_height); +return mrb_obj_value(Data_Wrap_Struct(mrb, rendertexture_mrb_class, &mrb_RenderTexture_struct, return_of_LoadRenderTexture)); +} + +//Texture LoadTexture +static mrb_value +mrb_LoadTexture(mrb_state* mrb, mrb_value self) { +char * parameter_fileName; + +mrb_get_args(mrb, "z", ¶meter_fileName); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *texture_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Texture_struct.struct_name); +Texture *return_of_LoadTexture = (Texture *)mrb_malloc(mrb, sizeof(Texture)); + +*return_of_LoadTexture = LoadTexture(parameter_fileName); +return mrb_obj_value(Data_Wrap_Struct(mrb, texture_mrb_class, &mrb_Texture_struct, return_of_LoadTexture)); +} + +//Texture LoadTextureFromImage +static mrb_value +mrb_LoadTextureFromImage(mrb_state* mrb, mrb_value self) { +mrb_value parameter_mrb_image; + +mrb_get_args(mrb, "o", ¶meter_mrb_image); +Image *parameter_image; +parameter_image = DATA_GET_PTR(mrb, parameter_mrb_image, &mrb_Image_struct, Image); +struct RClass *test_mrb_module = mrb_module_get(mrb, "Test"); +struct RClass *texture_mrb_class = mrb_class_get_under(mrb, test_mrb_module, mrb_Texture_struct.struct_name); +Texture *return_of_LoadTextureFromImage = (Texture *)mrb_malloc(mrb, sizeof(Texture)); + +*return_of_LoadTextureFromImage = LoadTextureFromImage(*parameter_image); +return mrb_obj_value(Data_Wrap_Struct(mrb, texture_mrb_class, &mrb_Texture_struct, return_of_LoadTextureFromImage)); +} + + + void + mrb_mruby_test_gem_init(mrb_state* mrb) { + struct RClass *test = mrb_define_module(mrb, "Test"); + + struct RClass *color_class = mrb_define_class_under(mrb, test, "Color", mrb->object_class); +MRB_SET_INSTANCE_TT(color_class, MRB_TT_DATA); + mrb_define_method(mrb, color_class, "a", mrb_Color_get_a, MRB_ARGS_NONE()); + mrb_define_method(mrb, color_class, "a=", mrb_Color_set_a, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, color_class, "b", mrb_Color_get_b, MRB_ARGS_NONE()); + mrb_define_method(mrb, color_class, "b=", mrb_Color_set_b, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, color_class, "g", mrb_Color_get_g, MRB_ARGS_NONE()); + mrb_define_method(mrb, color_class, "g=", mrb_Color_set_g, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, color_class, "r", mrb_Color_get_r, MRB_ARGS_NONE()); + mrb_define_method(mrb, color_class, "r=", mrb_Color_set_r, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, color_class, "initialize", mrb_Color_initialize, MRB_ARGS_OPT(1)); + + struct RClass *glyphinfo_class = mrb_define_class_under(mrb, test, "GlyphInfo", mrb->object_class); +MRB_SET_INSTANCE_TT(glyphinfo_class, MRB_TT_DATA); + mrb_define_method(mrb, glyphinfo_class, "advance_x", mrb_GlyphInfo_get_advanceX, MRB_ARGS_NONE()); + mrb_define_method(mrb, glyphinfo_class, "advance_x=", mrb_GlyphInfo_set_advanceX, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, glyphinfo_class, "offset_x", mrb_GlyphInfo_get_offsetX, MRB_ARGS_NONE()); + mrb_define_method(mrb, glyphinfo_class, "offset_x=", mrb_GlyphInfo_set_offsetX, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, glyphinfo_class, "offset_y", mrb_GlyphInfo_get_offsetY, MRB_ARGS_NONE()); + mrb_define_method(mrb, glyphinfo_class, "offset_y=", mrb_GlyphInfo_set_offsetY, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, glyphinfo_class, "value", mrb_GlyphInfo_get_value, MRB_ARGS_NONE()); + mrb_define_method(mrb, glyphinfo_class, "value=", mrb_GlyphInfo_set_value, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, glyphinfo_class, "initialize", mrb_GlyphInfo_initialize, MRB_ARGS_OPT(1)); + + struct RClass *mesh_class = mrb_define_class_under(mrb, test, "Mesh", mrb->object_class); +MRB_SET_INSTANCE_TT(mesh_class, MRB_TT_DATA); + mrb_define_method(mrb, mesh_class, "triangle_count", mrb_Mesh_get_triangleCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, mesh_class, "triangle_count=", mrb_Mesh_set_triangleCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, mesh_class, "vao_id", mrb_Mesh_get_vaoId, MRB_ARGS_NONE()); + mrb_define_method(mrb, mesh_class, "vao_id=", mrb_Mesh_set_vaoId, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, mesh_class, "vertex_count", mrb_Mesh_get_vertexCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, mesh_class, "vertex_count=", mrb_Mesh_set_vertexCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, mesh_class, "initialize", mrb_Mesh_initialize, MRB_ARGS_OPT(1)); + + struct RClass *font_class = mrb_define_class_under(mrb, test, "Font", mrb->object_class); +MRB_SET_INSTANCE_TT(font_class, MRB_TT_DATA); + mrb_define_method(mrb, font_class, "base_size", mrb_Font_get_baseSize, MRB_ARGS_NONE()); + mrb_define_method(mrb, font_class, "base_size=", mrb_Font_set_baseSize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, font_class, "glyph_count", mrb_Font_get_glyphCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, font_class, "glyph_count=", mrb_Font_set_glyphCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, font_class, "glyph_padding", mrb_Font_get_glyphPadding, MRB_ARGS_NONE()); + mrb_define_method(mrb, font_class, "glyph_padding=", mrb_Font_set_glyphPadding, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, font_class, "initialize", mrb_Font_initialize, MRB_ARGS_OPT(1)); + + struct RClass *model_class = mrb_define_class_under(mrb, test, "Model", mrb->object_class); +MRB_SET_INSTANCE_TT(model_class, MRB_TT_DATA); + mrb_define_method(mrb, model_class, "bone_count", mrb_Model_get_boneCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, model_class, "bone_count=", mrb_Model_set_boneCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, model_class, "material_count", mrb_Model_get_materialCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, model_class, "material_count=", mrb_Model_set_materialCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, model_class, "mesh_count", mrb_Model_get_meshCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, model_class, "mesh_count=", mrb_Model_set_meshCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, model_class, "initialize", mrb_Model_initialize, MRB_ARGS_OPT(1)); + + struct RClass *modelanimation_class = mrb_define_class_under(mrb, test, "ModelAnimation", mrb->object_class); +MRB_SET_INSTANCE_TT(modelanimation_class, MRB_TT_DATA); + mrb_define_method(mrb, modelanimation_class, "bone_count", mrb_ModelAnimation_get_boneCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, modelanimation_class, "bone_count=", mrb_ModelAnimation_set_boneCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, modelanimation_class, "frame_count", mrb_ModelAnimation_get_frameCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, modelanimation_class, "frame_count=", mrb_ModelAnimation_set_frameCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, modelanimation_class, "initialize", mrb_ModelAnimation_initialize, MRB_ARGS_OPT(1)); + + struct RClass *npatchinfo_class = mrb_define_class_under(mrb, test, "NPatchInfo", mrb->object_class); +MRB_SET_INSTANCE_TT(npatchinfo_class, MRB_TT_DATA); + mrb_define_method(mrb, npatchinfo_class, "bottom", mrb_NPatchInfo_get_bottom, MRB_ARGS_NONE()); + mrb_define_method(mrb, npatchinfo_class, "bottom=", mrb_NPatchInfo_set_bottom, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, npatchinfo_class, "layout", mrb_NPatchInfo_get_layout, MRB_ARGS_NONE()); + mrb_define_method(mrb, npatchinfo_class, "layout=", mrb_NPatchInfo_set_layout, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, npatchinfo_class, "left", mrb_NPatchInfo_get_left, MRB_ARGS_NONE()); + mrb_define_method(mrb, npatchinfo_class, "left=", mrb_NPatchInfo_set_left, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, npatchinfo_class, "right", mrb_NPatchInfo_get_right, MRB_ARGS_NONE()); + mrb_define_method(mrb, npatchinfo_class, "right=", mrb_NPatchInfo_set_right, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, npatchinfo_class, "top", mrb_NPatchInfo_get_top, MRB_ARGS_NONE()); + mrb_define_method(mrb, npatchinfo_class, "top=", mrb_NPatchInfo_set_top, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, npatchinfo_class, "initialize", mrb_NPatchInfo_initialize, MRB_ARGS_OPT(1)); + + struct RClass *audiostream_class = mrb_define_class_under(mrb, test, "AudioStream", mrb->object_class); +MRB_SET_INSTANCE_TT(audiostream_class, MRB_TT_DATA); + mrb_define_method(mrb, audiostream_class, "channels", mrb_AudioStream_get_channels, MRB_ARGS_NONE()); + mrb_define_method(mrb, audiostream_class, "channels=", mrb_AudioStream_set_channels, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, audiostream_class, "sample_rate", mrb_AudioStream_get_sampleRate, MRB_ARGS_NONE()); + mrb_define_method(mrb, audiostream_class, "sample_rate=", mrb_AudioStream_set_sampleRate, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, audiostream_class, "sample_size", mrb_AudioStream_get_sampleSize, MRB_ARGS_NONE()); + mrb_define_method(mrb, audiostream_class, "sample_size=", mrb_AudioStream_set_sampleSize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, audiostream_class, "initialize", mrb_AudioStream_initialize, MRB_ARGS_OPT(1)); + + struct RClass *wave_class = mrb_define_class_under(mrb, test, "Wave", mrb->object_class); +MRB_SET_INSTANCE_TT(wave_class, MRB_TT_DATA); + mrb_define_method(mrb, wave_class, "channels", mrb_Wave_get_channels, MRB_ARGS_NONE()); + mrb_define_method(mrb, wave_class, "channels=", mrb_Wave_set_channels, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, wave_class, "frame_count", mrb_Wave_get_frameCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, wave_class, "frame_count=", mrb_Wave_set_frameCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, wave_class, "sample_rate", mrb_Wave_get_sampleRate, MRB_ARGS_NONE()); + mrb_define_method(mrb, wave_class, "sample_rate=", mrb_Wave_set_sampleRate, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, wave_class, "sample_size", mrb_Wave_get_sampleSize, MRB_ARGS_NONE()); + mrb_define_method(mrb, wave_class, "sample_size=", mrb_Wave_set_sampleSize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, wave_class, "initialize", mrb_Wave_initialize, MRB_ARGS_OPT(1)); + + struct RClass *vrdeviceinfo_class = mrb_define_class_under(mrb, test, "VrDeviceInfo", mrb->object_class); +MRB_SET_INSTANCE_TT(vrdeviceinfo_class, MRB_TT_DATA); + mrb_define_method(mrb, vrdeviceinfo_class, "eye_to_screen_distance", mrb_VrDeviceInfo_get_eyeToScreenDistance, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "eye_to_screen_distance=", mrb_VrDeviceInfo_set_eyeToScreenDistance, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "h_resolution", mrb_VrDeviceInfo_get_hResolution, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "h_resolution=", mrb_VrDeviceInfo_set_hResolution, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "h_screen_size", mrb_VrDeviceInfo_get_hScreenSize, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "h_screen_size=", mrb_VrDeviceInfo_set_hScreenSize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "interpupillary_distance", mrb_VrDeviceInfo_get_interpupillaryDistance, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "interpupillary_distance=", mrb_VrDeviceInfo_set_interpupillaryDistance, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "lens_separation_distance", mrb_VrDeviceInfo_get_lensSeparationDistance, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "lens_separation_distance=", mrb_VrDeviceInfo_set_lensSeparationDistance, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "v_resolution", mrb_VrDeviceInfo_get_vResolution, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "v_resolution=", mrb_VrDeviceInfo_set_vResolution, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "v_screen_center", mrb_VrDeviceInfo_get_vScreenCenter, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "v_screen_center=", mrb_VrDeviceInfo_set_vScreenCenter, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "v_screen_size", mrb_VrDeviceInfo_get_vScreenSize, MRB_ARGS_NONE()); + mrb_define_method(mrb, vrdeviceinfo_class, "v_screen_size=", mrb_VrDeviceInfo_set_vScreenSize, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vrdeviceinfo_class, "initialize", mrb_VrDeviceInfo_initialize, MRB_ARGS_OPT(1)); + + struct RClass *materialmap_class = mrb_define_class_under(mrb, test, "MaterialMap", mrb->object_class); +MRB_SET_INSTANCE_TT(materialmap_class, MRB_TT_DATA); + mrb_define_method(mrb, materialmap_class, "value", mrb_MaterialMap_get_value, MRB_ARGS_NONE()); + mrb_define_method(mrb, materialmap_class, "value=", mrb_MaterialMap_set_value, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, materialmap_class, "initialize", mrb_MaterialMap_initialize, MRB_ARGS_OPT(1)); + + struct RClass *music_class = mrb_define_class_under(mrb, test, "Music", mrb->object_class); +MRB_SET_INSTANCE_TT(music_class, MRB_TT_DATA); + mrb_define_method(mrb, music_class, "ctx_type", mrb_Music_get_ctxType, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "ctx_type=", mrb_Music_set_ctxType, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, music_class, "frame_count", mrb_Music_get_frameCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "frame_count=", mrb_Music_set_frameCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, music_class, "looping", mrb_Music_get_looping, MRB_ARGS_NONE()); + mrb_define_method(mrb, music_class, "looping=", mrb_Music_set_looping, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, music_class, "initialize", mrb_Music_initialize, MRB_ARGS_OPT(1)); + + struct RClass *image_class = mrb_define_class_under(mrb, test, "Image", mrb->object_class); +MRB_SET_INSTANCE_TT(image_class, MRB_TT_DATA); + mrb_define_method(mrb, image_class, "format", mrb_Image_get_format, MRB_ARGS_NONE()); + mrb_define_method(mrb, image_class, "format=", mrb_Image_set_format, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, image_class, "height", mrb_Image_get_height, MRB_ARGS_NONE()); + mrb_define_method(mrb, image_class, "height=", mrb_Image_set_height, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, image_class, "mipmaps", mrb_Image_get_mipmaps, MRB_ARGS_NONE()); + mrb_define_method(mrb, image_class, "mipmaps=", mrb_Image_set_mipmaps, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, image_class, "width", mrb_Image_get_width, MRB_ARGS_NONE()); + mrb_define_method(mrb, image_class, "width=", mrb_Image_set_width, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, image_class, "initialize", mrb_Image_initialize, MRB_ARGS_OPT(1)); + + struct RClass *rendertexture_class = mrb_define_class_under(mrb, test, "RenderTexture", mrb->object_class); +MRB_SET_INSTANCE_TT(rendertexture_class, MRB_TT_DATA); + mrb_define_method(mrb, rendertexture_class, "id", mrb_RenderTexture_get_id, MRB_ARGS_NONE()); + mrb_define_method(mrb, rendertexture_class, "id=", mrb_RenderTexture_set_id, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rendertexture_class, "initialize", mrb_RenderTexture_initialize, MRB_ARGS_OPT(1)); + + struct RClass *ray_class = mrb_define_class_under(mrb, test, "Ray", mrb->object_class); +MRB_SET_INSTANCE_TT(ray_class, MRB_TT_DATA); + mrb_define_method(mrb, ray_class, "initialize", mrb_Ray_initialize, MRB_ARGS_OPT(1)); + + struct RClass *raycollision_class = mrb_define_class_under(mrb, test, "RayCollision", mrb->object_class); +MRB_SET_INSTANCE_TT(raycollision_class, MRB_TT_DATA); + mrb_define_method(mrb, raycollision_class, "distance", mrb_RayCollision_get_distance, MRB_ARGS_NONE()); + mrb_define_method(mrb, raycollision_class, "distance=", mrb_RayCollision_set_distance, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, raycollision_class, "hit", mrb_RayCollision_get_hit, MRB_ARGS_NONE()); + mrb_define_method(mrb, raycollision_class, "hit=", mrb_RayCollision_set_hit, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, raycollision_class, "initialize", mrb_RayCollision_initialize, MRB_ARGS_OPT(1)); + + struct RClass *texture_class = mrb_define_class_under(mrb, test, "Texture", mrb->object_class); +MRB_SET_INSTANCE_TT(texture_class, MRB_TT_DATA); + mrb_define_method(mrb, texture_class, "format", mrb_Texture_get_format, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "format=", mrb_Texture_set_format, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, texture_class, "height", mrb_Texture_get_height, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "height=", mrb_Texture_set_height, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, texture_class, "id", mrb_Texture_get_id, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "id=", mrb_Texture_set_id, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, texture_class, "mipmaps", mrb_Texture_get_mipmaps, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "mipmaps=", mrb_Texture_set_mipmaps, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, texture_class, "width", mrb_Texture_get_width, MRB_ARGS_NONE()); + mrb_define_method(mrb, texture_class, "width=", mrb_Texture_set_width, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, texture_class, "initialize", mrb_Texture_initialize, MRB_ARGS_OPT(1)); + + struct RClass *camera3d_class = mrb_define_class_under(mrb, test, "Camera3D", mrb->object_class); +MRB_SET_INSTANCE_TT(camera3d_class, MRB_TT_DATA); + mrb_define_method(mrb, camera3d_class, "fovy", mrb_Camera3D_get_fovy, MRB_ARGS_NONE()); + mrb_define_method(mrb, camera3d_class, "fovy=", mrb_Camera3D_set_fovy, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, camera3d_class, "projection", mrb_Camera3D_get_projection, MRB_ARGS_NONE()); + mrb_define_method(mrb, camera3d_class, "projection=", mrb_Camera3D_set_projection, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, camera3d_class, "initialize", mrb_Camera3D_initialize, MRB_ARGS_OPT(1)); + + struct RClass *sound_class = mrb_define_class_under(mrb, test, "Sound", mrb->object_class); +MRB_SET_INSTANCE_TT(sound_class, MRB_TT_DATA); + mrb_define_method(mrb, sound_class, "frame_count", mrb_Sound_get_frameCount, MRB_ARGS_NONE()); + mrb_define_method(mrb, sound_class, "frame_count=", mrb_Sound_set_frameCount, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, sound_class, "initialize", mrb_Sound_initialize, MRB_ARGS_OPT(1)); + + struct RClass *rectangle_class = mrb_define_class_under(mrb, test, "Rectangle", mrb->object_class); +MRB_SET_INSTANCE_TT(rectangle_class, MRB_TT_DATA); + mrb_define_method(mrb, rectangle_class, "height", mrb_Rectangle_get_height, MRB_ARGS_NONE()); + mrb_define_method(mrb, rectangle_class, "height=", mrb_Rectangle_set_height, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rectangle_class, "width", mrb_Rectangle_get_width, MRB_ARGS_NONE()); + mrb_define_method(mrb, rectangle_class, "width=", mrb_Rectangle_set_width, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rectangle_class, "x", mrb_Rectangle_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, rectangle_class, "x=", mrb_Rectangle_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rectangle_class, "y", mrb_Rectangle_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, rectangle_class, "y=", mrb_Rectangle_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, rectangle_class, "initialize", mrb_Rectangle_initialize, MRB_ARGS_OPT(1)); + + struct RClass *shader_class = mrb_define_class_under(mrb, test, "Shader", mrb->object_class); +MRB_SET_INSTANCE_TT(shader_class, MRB_TT_DATA); + mrb_define_method(mrb, shader_class, "id", mrb_Shader_get_id, MRB_ARGS_NONE()); + mrb_define_method(mrb, shader_class, "id=", mrb_Shader_set_id, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, shader_class, "initialize", mrb_Shader_initialize, MRB_ARGS_OPT(1)); + + struct RClass *vrstereoconfig_class = mrb_define_class_under(mrb, test, "VrStereoConfig", mrb->object_class); +MRB_SET_INSTANCE_TT(vrstereoconfig_class, MRB_TT_DATA); + mrb_define_method(mrb, vrstereoconfig_class, "initialize", mrb_VrStereoConfig_initialize, MRB_ARGS_OPT(1)); + + struct RClass *matrix_class = mrb_define_class_under(mrb, test, "Matrix", mrb->object_class); +MRB_SET_INSTANCE_TT(matrix_class, MRB_TT_DATA); + mrb_define_method(mrb, matrix_class, "m0", mrb_Matrix_get_m0, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m0=", mrb_Matrix_set_m0, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m1", mrb_Matrix_get_m1, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m1=", mrb_Matrix_set_m1, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m10", mrb_Matrix_get_m10, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m10=", mrb_Matrix_set_m10, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m11", mrb_Matrix_get_m11, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m11=", mrb_Matrix_set_m11, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m12", mrb_Matrix_get_m12, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m12=", mrb_Matrix_set_m12, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m13", mrb_Matrix_get_m13, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m13=", mrb_Matrix_set_m13, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m14", mrb_Matrix_get_m14, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m14=", mrb_Matrix_set_m14, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m15", mrb_Matrix_get_m15, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m15=", mrb_Matrix_set_m15, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m2", mrb_Matrix_get_m2, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m2=", mrb_Matrix_set_m2, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m3", mrb_Matrix_get_m3, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m3=", mrb_Matrix_set_m3, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m4", mrb_Matrix_get_m4, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m4=", mrb_Matrix_set_m4, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m5", mrb_Matrix_get_m5, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m5=", mrb_Matrix_set_m5, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m6", mrb_Matrix_get_m6, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m6=", mrb_Matrix_set_m6, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m7", mrb_Matrix_get_m7, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m7=", mrb_Matrix_set_m7, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m8", mrb_Matrix_get_m8, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m8=", mrb_Matrix_set_m8, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "m9", mrb_Matrix_get_m9, MRB_ARGS_NONE()); + mrb_define_method(mrb, matrix_class, "m9=", mrb_Matrix_set_m9, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, matrix_class, "initialize", mrb_Matrix_initialize, MRB_ARGS_OPT(1)); + + struct RClass *material_class = mrb_define_class_under(mrb, test, "Material", mrb->object_class); +MRB_SET_INSTANCE_TT(material_class, MRB_TT_DATA); + mrb_define_method(mrb, material_class, "initialize", mrb_Material_initialize, MRB_ARGS_OPT(1)); + + struct RClass *boundingbox_class = mrb_define_class_under(mrb, test, "BoundingBox", mrb->object_class); +MRB_SET_INSTANCE_TT(boundingbox_class, MRB_TT_DATA); + mrb_define_method(mrb, boundingbox_class, "initialize", mrb_BoundingBox_initialize, MRB_ARGS_OPT(1)); + + struct RClass *boneinfo_class = mrb_define_class_under(mrb, test, "BoneInfo", mrb->object_class); +MRB_SET_INSTANCE_TT(boneinfo_class, MRB_TT_DATA); + mrb_define_method(mrb, boneinfo_class, "parent", mrb_BoneInfo_get_parent, MRB_ARGS_NONE()); + mrb_define_method(mrb, boneinfo_class, "parent=", mrb_BoneInfo_set_parent, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, boneinfo_class, "initialize", mrb_BoneInfo_initialize, MRB_ARGS_OPT(1)); + + struct RClass *camera2d_class = mrb_define_class_under(mrb, test, "Camera2D", mrb->object_class); +MRB_SET_INSTANCE_TT(camera2d_class, MRB_TT_DATA); + mrb_define_method(mrb, camera2d_class, "rotation", mrb_Camera2D_get_rotation, MRB_ARGS_NONE()); + mrb_define_method(mrb, camera2d_class, "rotation=", mrb_Camera2D_set_rotation, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, camera2d_class, "zoom", mrb_Camera2D_get_zoom, MRB_ARGS_NONE()); + mrb_define_method(mrb, camera2d_class, "zoom=", mrb_Camera2D_set_zoom, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, camera2d_class, "initialize", mrb_Camera2D_initialize, MRB_ARGS_OPT(1)); + + struct RClass *transform_class = mrb_define_class_under(mrb, test, "Transform", mrb->object_class); +MRB_SET_INSTANCE_TT(transform_class, MRB_TT_DATA); + mrb_define_method(mrb, transform_class, "initialize", mrb_Transform_initialize, MRB_ARGS_OPT(1)); + + struct RClass *vector4_class = mrb_define_class_under(mrb, test, "Vector4", mrb->object_class); +MRB_SET_INSTANCE_TT(vector4_class, MRB_TT_DATA); + mrb_define_method(mrb, vector4_class, "w", mrb_Vector4_get_w, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "w=", mrb_Vector4_set_w, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "x", mrb_Vector4_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "x=", mrb_Vector4_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "y", mrb_Vector4_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "y=", mrb_Vector4_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "z", mrb_Vector4_get_z, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector4_class, "z=", mrb_Vector4_set_z, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector4_class, "initialize", mrb_Vector4_initialize, MRB_ARGS_OPT(1)); + + struct RClass *vector2_class = mrb_define_class_under(mrb, test, "Vector2", mrb->object_class); +MRB_SET_INSTANCE_TT(vector2_class, MRB_TT_DATA); + mrb_define_method(mrb, vector2_class, "x", mrb_Vector2_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "x=", mrb_Vector2_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "y", mrb_Vector2_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector2_class, "y=", mrb_Vector2_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector2_class, "initialize", mrb_Vector2_initialize, MRB_ARGS_OPT(1)); + + struct RClass *vector3_class = mrb_define_class_under(mrb, test, "Vector3", mrb->object_class); +MRB_SET_INSTANCE_TT(vector3_class, MRB_TT_DATA); + mrb_define_method(mrb, vector3_class, "x", mrb_Vector3_get_x, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "x=", mrb_Vector3_set_x, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "y", mrb_Vector3_get_y, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "y=", mrb_Vector3_set_y, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "z", mrb_Vector3_get_z, MRB_ARGS_NONE()); + mrb_define_method(mrb, vector3_class, "z=", mrb_Vector3_set_z, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, vector3_class, "initialize", mrb_Vector3_initialize, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_blend_mode", mrb_BeginBlendMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_drawing", mrb_BeginDrawing, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_mode2_d", mrb_BeginMode2D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_mode3_d", mrb_BeginMode3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_scissor_mode", mrb_BeginScissorMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_shader_mode", mrb_BeginShaderMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_texture_mode", mrb_BeginTextureMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "begin_vr_stereo_mode", mrb_BeginVrStereoMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "change_directory", mrb_ChangeDirectory, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_box_sphere", mrb_CheckCollisionBoxSphere, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_boxes", mrb_CheckCollisionBoxes, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_circle_rec", mrb_CheckCollisionCircleRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_circles", mrb_CheckCollisionCircles, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_lines", mrb_CheckCollisionLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_point_circle", mrb_CheckCollisionPointCircle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_point_line", mrb_CheckCollisionPointLine, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_point_rec", mrb_CheckCollisionPointRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_point_triangle", mrb_CheckCollisionPointTriangle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_recs", mrb_CheckCollisionRecs, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "check_collision_spheres", mrb_CheckCollisionSpheres, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "clear_background", mrb_ClearBackground, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "clear_directory_files", mrb_ClearDirectoryFiles, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "clear_dropped_files", mrb_ClearDroppedFiles, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "clear_window_state", mrb_ClearWindowState, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "close_audio_device", mrb_CloseAudioDevice, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "close_window", mrb_CloseWindow, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "codepoint_to_utf8", mrb_CodepointToUTF8, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_alpha", mrb_ColorAlpha, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_alpha_blend", mrb_ColorAlphaBlend, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_from_hsv", mrb_ColorFromHSV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_from_normalized", mrb_ColorFromNormalized, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_normalize", mrb_ColorNormalize, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_to_hsv", mrb_ColorToHSV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color_to_int", mrb_ColorToInt, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "directory_exists", mrb_DirectoryExists, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "disable_cursor", mrb_DisableCursor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_bounding_box", mrb_DrawBoundingBox, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle", mrb_DrawCircle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle3_d", mrb_DrawCircle3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle_gradient", mrb_DrawCircleGradient, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle_lines", mrb_DrawCircleLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle_sector", mrb_DrawCircleSector, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle_sector_lines", mrb_DrawCircleSectorLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_circle_v", mrb_DrawCircleV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cube", mrb_DrawCube, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cube_texture", mrb_DrawCubeTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cube_texture_rec", mrb_DrawCubeTextureRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cube_v", mrb_DrawCubeV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cube_wires", mrb_DrawCubeWires, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cube_wires_v", mrb_DrawCubeWiresV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cylinder", mrb_DrawCylinder, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cylinder_ex", mrb_DrawCylinderEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cylinder_wires", mrb_DrawCylinderWires, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_cylinder_wires_ex", mrb_DrawCylinderWiresEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_ellipse", mrb_DrawEllipse, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_ellipse_lines", mrb_DrawEllipseLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_fps", mrb_DrawFPS, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_grid", mrb_DrawGrid, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line", mrb_DrawLine, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line3_d", mrb_DrawLine3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line_bezier", mrb_DrawLineBezier, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line_bezier_cubic", mrb_DrawLineBezierCubic, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line_bezier_quad", mrb_DrawLineBezierQuad, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line_ex", mrb_DrawLineEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line_strip", mrb_DrawLineStrip, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_line_v", mrb_DrawLineV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_mesh", mrb_DrawMesh, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_model", mrb_DrawModel, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_model_ex", mrb_DrawModelEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_model_wires", mrb_DrawModelWires, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_model_wires_ex", mrb_DrawModelWiresEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_pixel", mrb_DrawPixel, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_pixel_v", mrb_DrawPixelV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_plane", mrb_DrawPlane, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_point3_d", mrb_DrawPoint3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_poly", mrb_DrawPoly, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_poly_lines", mrb_DrawPolyLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_poly_lines_ex", mrb_DrawPolyLinesEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_ray", mrb_DrawRay, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle", mrb_DrawRectangle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_gradient_ex", mrb_DrawRectangleGradientEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_gradient_h", mrb_DrawRectangleGradientH, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_gradient_v", mrb_DrawRectangleGradientV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_lines", mrb_DrawRectangleLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_lines_ex", mrb_DrawRectangleLinesEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_pro", mrb_DrawRectanglePro, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_rec", mrb_DrawRectangleRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_rounded", mrb_DrawRectangleRounded, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_rounded_lines", mrb_DrawRectangleRoundedLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_rectangle_v", mrb_DrawRectangleV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_ring", mrb_DrawRing, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_ring_lines", mrb_DrawRingLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_sphere", mrb_DrawSphere, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_sphere_ex", mrb_DrawSphereEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_sphere_wires", mrb_DrawSphereWires, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_text", mrb_DrawText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_text_codepoint", mrb_DrawTextCodepoint, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_text_ex", mrb_DrawTextEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_text_pro", mrb_DrawTextPro, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture", mrb_DrawTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_ex", mrb_DrawTextureEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_n_patch", mrb_DrawTextureNPatch, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_poly", mrb_DrawTexturePoly, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_pro", mrb_DrawTexturePro, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_quad", mrb_DrawTextureQuad, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_rec", mrb_DrawTextureRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_tiled", mrb_DrawTextureTiled, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_texture_v", mrb_DrawTextureV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_triangle", mrb_DrawTriangle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_triangle3_d", mrb_DrawTriangle3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_triangle_fan", mrb_DrawTriangleFan, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_triangle_lines", mrb_DrawTriangleLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_triangle_strip", mrb_DrawTriangleStrip, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "draw_triangle_strip3_d", mrb_DrawTriangleStrip3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "enable_cursor", mrb_EnableCursor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_blend_mode", mrb_EndBlendMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_drawing", mrb_EndDrawing, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_mode2_d", mrb_EndMode2D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_mode3_d", mrb_EndMode3D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_scissor_mode", mrb_EndScissorMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_shader_mode", mrb_EndShaderMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_texture_mode", mrb_EndTextureMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "end_vr_stereo_mode", mrb_EndVrStereoMode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "export_font_as_code", mrb_ExportFontAsCode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "export_image", mrb_ExportImage, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "export_image_as_code", mrb_ExportImageAsCode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "export_mesh", mrb_ExportMesh, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "export_wave", mrb_ExportWave, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "export_wave_as_code", mrb_ExportWaveAsCode, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "fade", mrb_Fade, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_exists", mrb_FileExists, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_cellular", mrb_GenImageCellular, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_checked", mrb_GenImageChecked, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_color", mrb_GenImageColor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_gradient_h", mrb_GenImageGradientH, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_gradient_radial", mrb_GenImageGradientRadial, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_gradient_v", mrb_GenImageGradientV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_image_white_noise", mrb_GenImageWhiteNoise, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_binormals", mrb_GenMeshBinormals, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_cone", mrb_GenMeshCone, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_cube", mrb_GenMeshCube, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_cubicmap", mrb_GenMeshCubicmap, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_cylinder", mrb_GenMeshCylinder, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_heightmap", mrb_GenMeshHeightmap, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_hemi_sphere", mrb_GenMeshHemiSphere, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_knot", mrb_GenMeshKnot, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_plane", mrb_GenMeshPlane, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_poly", mrb_GenMeshPoly, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_sphere", mrb_GenMeshSphere, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_tangents", mrb_GenMeshTangents, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gen_mesh_torus", mrb_GenMeshTorus, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "application_directory", mrb_GetApplicationDirectory, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "camera_matrix2_d", mrb_GetCameraMatrix2D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "char_pressed", mrb_GetCharPressed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "clipboard_text", mrb_GetClipboardText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "codepoint", mrb_GetCodepoint, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "codepoint_count", mrb_GetCodepointCount, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "collision_rec", mrb_GetCollisionRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "color", mrb_GetColor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "current_monitor", mrb_GetCurrentMonitor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "directory_path", mrb_GetDirectoryPath, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "fps", mrb_GetFPS, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_extension", mrb_GetFileExtension, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_length", mrb_GetFileLength, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_mod_time", mrb_GetFileModTime, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_name", mrb_GetFileName, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_name_without_ext", mrb_GetFileNameWithoutExt, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "font_default", mrb_GetFontDefault, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "frame_time", mrb_GetFrameTime, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_axis_count", mrb_GetGamepadAxisCount, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_axis_movement", mrb_GetGamepadAxisMovement, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_button_pressed", mrb_GetGamepadButtonPressed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_name", mrb_GetGamepadName, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_detected", mrb_GetGestureDetected, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_drag_angle", mrb_GetGestureDragAngle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_drag_vector", mrb_GetGestureDragVector, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_hold_duration", mrb_GetGestureHoldDuration, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_pinch_angle", mrb_GetGesturePinchAngle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_pinch_vector", mrb_GetGesturePinchVector, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "glyph_atlas_rec", mrb_GetGlyphAtlasRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "glyph_index", mrb_GetGlyphIndex, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "glyph_info", mrb_GetGlyphInfo, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_alpha_border", mrb_GetImageAlphaBorder, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color", mrb_GetImageColor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "key_pressed", mrb_GetKeyPressed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mesh_bounding_box", mrb_GetMeshBoundingBox, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "model_bounding_box", mrb_GetModelBoundingBox, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_count", mrb_GetMonitorCount, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_height", mrb_GetMonitorHeight, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_name", mrb_GetMonitorName, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_physical_height", mrb_GetMonitorPhysicalHeight, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_physical_width", mrb_GetMonitorPhysicalWidth, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_position", mrb_GetMonitorPosition, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_refresh_rate", mrb_GetMonitorRefreshRate, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "monitor_width", mrb_GetMonitorWidth, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_delta", mrb_GetMouseDelta, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_position", mrb_GetMousePosition, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_wheel_move", mrb_GetMouseWheelMove, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_x", mrb_GetMouseX, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_y", mrb_GetMouseY, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "music_time_length", mrb_GetMusicTimeLength, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "music_time_played", mrb_GetMusicTimePlayed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "pixel_data_size", mrb_GetPixelDataSize, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "prev_directory_path", mrb_GetPrevDirectoryPath, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "random_value", mrb_GetRandomValue, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "ray_collision_box", mrb_GetRayCollisionBox, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "ray_collision_mesh", mrb_GetRayCollisionMesh, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "ray_collision_quad", mrb_GetRayCollisionQuad, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "ray_collision_sphere", mrb_GetRayCollisionSphere, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "ray_collision_triangle", mrb_GetRayCollisionTriangle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "render_height", mrb_GetRenderHeight, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "render_width", mrb_GetRenderWidth, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "screen_height", mrb_GetScreenHeight, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "screen_to_world2_d", mrb_GetScreenToWorld2D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "screen_width", mrb_GetScreenWidth, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "shader_location", mrb_GetShaderLocation, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "shader_location_attrib", mrb_GetShaderLocationAttrib, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "sounds_playing", mrb_GetSoundsPlaying, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "time", mrb_GetTime, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "touch_point_count", mrb_GetTouchPointCount, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "touch_point_id", mrb_GetTouchPointId, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "touch_position", mrb_GetTouchPosition, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "touch_x", mrb_GetTouchX, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "touch_y", mrb_GetTouchY, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_position", mrb_GetWindowPosition, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_scale_dpi", mrb_GetWindowScaleDPI, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "working_directory", mrb_GetWorkingDirectory, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "world_to_screen2_d", mrb_GetWorldToScreen2D, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "hide_cursor", mrb_HideCursor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_alpha_clear", mrb_ImageAlphaClear, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_alpha_crop", mrb_ImageAlphaCrop, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_alpha_mask", mrb_ImageAlphaMask, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_alpha_premultiply", mrb_ImageAlphaPremultiply, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_clear_background", mrb_ImageClearBackground, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color_brightness", mrb_ImageColorBrightness, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color_contrast", mrb_ImageColorContrast, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color_grayscale", mrb_ImageColorGrayscale, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color_invert", mrb_ImageColorInvert, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color_replace", mrb_ImageColorReplace, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_color_tint", mrb_ImageColorTint, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_copy", mrb_ImageCopy, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_crop", mrb_ImageCrop, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_dither", mrb_ImageDither, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw", mrb_ImageDraw, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_circle", mrb_ImageDrawCircle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_circle_v", mrb_ImageDrawCircleV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_line", mrb_ImageDrawLine, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_line_v", mrb_ImageDrawLineV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_pixel", mrb_ImageDrawPixel, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_pixel_v", mrb_ImageDrawPixelV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_rectangle", mrb_ImageDrawRectangle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_rectangle_lines", mrb_ImageDrawRectangleLines, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_rectangle_rec", mrb_ImageDrawRectangleRec, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_rectangle_v", mrb_ImageDrawRectangleV, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_text", mrb_ImageDrawText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_draw_text_ex", mrb_ImageDrawTextEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_flip_horizontal", mrb_ImageFlipHorizontal, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_flip_vertical", mrb_ImageFlipVertical, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_format", mrb_ImageFormat, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_from_image", mrb_ImageFromImage, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_mipmaps", mrb_ImageMipmaps, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_resize", mrb_ImageResize, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_resize_canvas", mrb_ImageResizeCanvas, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_resize_nn", mrb_ImageResizeNN, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_rotate_ccw", mrb_ImageRotateCCW, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_rotate_cw", mrb_ImageRotateCW, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_text", mrb_ImageText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_text_ex", mrb_ImageTextEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "image_to_pot", mrb_ImageToPOT, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "init_audio_device", mrb_InitAudioDevice, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "init_window", mrb_InitWindow, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "audio_device_ready?", mrb_IsAudioDeviceReady, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "audio_stream_playing?", mrb_IsAudioStreamPlaying, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "audio_stream_processed?", mrb_IsAudioStreamProcessed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "cursor_hidden?", mrb_IsCursorHidden, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "cursor_on_screen?", mrb_IsCursorOnScreen, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_dropped?", mrb_IsFileDropped, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "file_extension?", mrb_IsFileExtension, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_available?", mrb_IsGamepadAvailable, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_button_down?", mrb_IsGamepadButtonDown, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_button_pressed?", mrb_IsGamepadButtonPressed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_button_released?", mrb_IsGamepadButtonReleased, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_button_up?", mrb_IsGamepadButtonUp, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gesture_detected?", mrb_IsGestureDetected, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "key_down?", mrb_IsKeyDown, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "key_pressed?", mrb_IsKeyPressed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "key_released?", mrb_IsKeyReleased, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "key_up?", mrb_IsKeyUp, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "model_animation_valid?", mrb_IsModelAnimationValid, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_button_down?", mrb_IsMouseButtonDown, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_button_pressed?", mrb_IsMouseButtonPressed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_button_released?", mrb_IsMouseButtonReleased, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_button_up?", mrb_IsMouseButtonUp, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "music_stream_playing?", mrb_IsMusicStreamPlaying, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "sound_playing?", mrb_IsSoundPlaying, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_focused?", mrb_IsWindowFocused, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_fullscreen?", mrb_IsWindowFullscreen, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_hidden?", mrb_IsWindowHidden, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_maximized?", mrb_IsWindowMaximized, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_minimized?", mrb_IsWindowMinimized, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_ready?", mrb_IsWindowReady, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_resized?", mrb_IsWindowResized, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_state?", mrb_IsWindowState, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_audio_stream", mrb_LoadAudioStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_codepoints", mrb_LoadCodepoints, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_file_data", mrb_LoadFileData, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_file_text", mrb_LoadFileText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_font", mrb_LoadFont, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_font_ex", mrb_LoadFontEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_font_from_image", mrb_LoadFontFromImage, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image", mrb_LoadImage, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image_anim", mrb_LoadImageAnim, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image_colors", mrb_LoadImageColors, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image_from_screen", mrb_LoadImageFromScreen, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image_from_texture", mrb_LoadImageFromTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image_palette", mrb_LoadImagePalette, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_image_raw", mrb_LoadImageRaw, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_material_default", mrb_LoadMaterialDefault, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_materials", mrb_LoadMaterials, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_model", mrb_LoadModel, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_model_animations", mrb_LoadModelAnimations, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_model_from_mesh", mrb_LoadModelFromMesh, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_music_stream", mrb_LoadMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_shader", mrb_LoadShader, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_shader_from_memory", mrb_LoadShaderFromMemory, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_sound", mrb_LoadSound, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_sound_from_wave", mrb_LoadSoundFromWave, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_storage_value", mrb_LoadStorageValue, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_vr_stereo_config", mrb_LoadVrStereoConfig, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_wave", mrb_LoadWave, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_wave_samples", mrb_LoadWaveSamples, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "maximize_window", mrb_MaximizeWindow, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "measure_text", mrb_MeasureText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "measure_text_ex", mrb_MeasureTextEx, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "minimize_window", mrb_MinimizeWindow, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "open_url", mrb_OpenURL, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "pause_audio_stream", mrb_PauseAudioStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "pause_music_stream", mrb_PauseMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "pause_sound", mrb_PauseSound, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "play_audio_stream", mrb_PlayAudioStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "play_music_stream", mrb_PlayMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "play_sound", mrb_PlaySound, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "play_sound_multi", mrb_PlaySoundMulti, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "poll_input_events", mrb_PollInputEvents, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "restore_window", mrb_RestoreWindow, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "resume_audio_stream", mrb_ResumeAudioStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "resume_music_stream", mrb_ResumeMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "resume_sound", mrb_ResumeSound, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "save_file_text", mrb_SaveFileText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "save_storage_value", mrb_SaveStorageValue, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "seek_music_stream", mrb_SeekMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "audio_stream_buffer_size_default=", mrb_SetAudioStreamBufferSizeDefault, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_audio_stream_pan", mrb_SetAudioStreamPan, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_audio_stream_pitch", mrb_SetAudioStreamPitch, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_audio_stream_volume", mrb_SetAudioStreamVolume, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "camera_alt_control=", mrb_SetCameraAltControl, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_camera_move_controls", mrb_SetCameraMoveControls, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "camera_pan_control=", mrb_SetCameraPanControl, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "camera_smooth_zoom_control=", mrb_SetCameraSmoothZoomControl, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "clipboard_text=", mrb_SetClipboardText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "config_flags=", mrb_SetConfigFlags, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "exit_key=", mrb_SetExitKey, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gamepad_mappings=", mrb_SetGamepadMappings, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "gestures_enabled=", mrb_SetGesturesEnabled, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "master_volume=", mrb_SetMasterVolume, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_material_texture", mrb_SetMaterialTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_model_mesh_material", mrb_SetModelMeshMaterial, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "mouse_cursor=", mrb_SetMouseCursor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_mouse_offset", mrb_SetMouseOffset, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_mouse_position", mrb_SetMousePosition, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_mouse_scale", mrb_SetMouseScale, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_music_pan", mrb_SetMusicPan, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_music_pitch", mrb_SetMusicPitch, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_music_volume", mrb_SetMusicVolume, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "random_seed=", mrb_SetRandomSeed, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_shader_value_matrix", mrb_SetShaderValueMatrix, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_shader_value_texture", mrb_SetShaderValueTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_shapes_texture", mrb_SetShapesTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_sound_pan", mrb_SetSoundPan, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_sound_pitch", mrb_SetSoundPitch, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_sound_volume", mrb_SetSoundVolume, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "target_fps=", mrb_SetTargetFPS, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_texture_filter", mrb_SetTextureFilter, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_texture_wrap", mrb_SetTextureWrap, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "trace_log_level=", mrb_SetTraceLogLevel, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_icon=", mrb_SetWindowIcon, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_window_min_size", mrb_SetWindowMinSize, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_monitor=", mrb_SetWindowMonitor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_opacity=", mrb_SetWindowOpacity, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_window_position", mrb_SetWindowPosition, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "set_window_size", mrb_SetWindowSize, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_state=", mrb_SetWindowState, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_title=", mrb_SetWindowTitle, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "show_cursor", mrb_ShowCursor, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "stop_audio_stream", mrb_StopAudioStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "stop_music_stream", mrb_StopMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "stop_sound", mrb_StopSound, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "stop_sound_multi", mrb_StopSoundMulti, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "swap_screen_buffer", mrb_SwapScreenBuffer, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "take_screenshot", mrb_TakeScreenshot, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_append", mrb_TextAppend, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_copy", mrb_TextCopy, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_find_index", mrb_TextFindIndex, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_insert", mrb_TextInsert, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_is_equal", mrb_TextIsEqual, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_length", mrb_TextLength, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_replace", mrb_TextReplace, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_subtext", mrb_TextSubtext, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_to_integer", mrb_TextToInteger, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_to_lower", mrb_TextToLower, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_to_pascal", mrb_TextToPascal, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "text_to_upper", mrb_TextToUpper, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "toggle_fullscreen", mrb_ToggleFullscreen, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_audio_stream", mrb_UnloadAudioStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_codepoints", mrb_UnloadCodepoints, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_file_data", mrb_UnloadFileData, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_file_text", mrb_UnloadFileText, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_font", mrb_UnloadFont, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_font_data", mrb_UnloadFontData, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_image", mrb_UnloadImage, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_image_colors", mrb_UnloadImageColors, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_image_palette", mrb_UnloadImagePalette, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_material", mrb_UnloadMaterial, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_mesh", mrb_UnloadMesh, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_model", mrb_UnloadModel, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_model_animation", mrb_UnloadModelAnimation, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_model_animations", mrb_UnloadModelAnimations, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_model_keep_meshes", mrb_UnloadModelKeepMeshes, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_music_stream", mrb_UnloadMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_render_texture", mrb_UnloadRenderTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_shader", mrb_UnloadShader, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_sound", mrb_UnloadSound, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_texture", mrb_UnloadTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_vr_stereo_config", mrb_UnloadVrStereoConfig, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_wave", mrb_UnloadWave, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "unload_wave_samples", mrb_UnloadWaveSamples, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "update_model_animation", mrb_UpdateModelAnimation, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "update_music_stream", mrb_UpdateMusicStream, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "upload_mesh", mrb_UploadMesh, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "wait_time", mrb_WaitTime, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "wave_copy", mrb_WaveCopy, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "wave_crop", mrb_WaveCrop, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "wave_format", mrb_WaveFormat, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "window_should_close", mrb_WindowShouldClose, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_render_texture", mrb_LoadRenderTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_texture", mrb_LoadTexture, MRB_ARGS_OPT(1)); + + mrb_define_module_function(mrb, test, "load_texture_from_image", mrb_LoadTextureFromImage, MRB_ARGS_OPT(1)); + +} + +void +mrb_mruby_test_gem_final(mrb_state* mrb) { + +} + +/* Unbound: +void * MemAlloc +void AttachAudioStreamProcessor +unsigned char * CompressData +unsigned char * DecodeDataBase64 +unsigned char * DecompressData +void DetachAudioStreamProcessor +void DrawBillboard +void DrawBillboardPro +void DrawBillboardRec +void DrawMeshInstanced +void DrawTextCodepoints +char * EncodeDataBase64 +Image GenImageFontAtlas +void GenTextureMipmaps +Matrix GetCameraMatrix +char ** GetDirectoryFiles +char ** GetDroppedFiles +Ray GetMouseRay +Color GetPixelColor +void * GetWindowHandle +Vector2 GetWorldToScreen +Vector2 GetWorldToScreenEx +GlyphInfo * LoadFontData +Font LoadFontFromMemory +Image LoadImageFromMemory +Music LoadMusicStreamFromMemory +TextureCubemap LoadTextureCubemap +Wave LoadWaveFromMemory +void MemFree +void * MemRealloc +bool SaveFileData +void SetAudioStreamCallback +void SetCameraMode +void SetLoadFileDataCallback +void SetLoadFileTextCallback +void SetPixelColor +void SetSaveFileDataCallback +void SetSaveFileTextCallback +void SetShaderValue +void SetShaderValueV +void SetTraceLogCallback +char * TextCodepointsToUTF8 +const char * TextFormat +const char * TextJoin +const char ** TextSplit +void TraceLog +void UpdateAudioStream +void UpdateCamera +void UpdateMeshBuffer +void UpdateSound +void UpdateTexture +void UpdateTextureRec +*/ +//Bound Functions: 447 / 499 +//--- +//Struct Accessors: 91 / 156 +//--- + +/* +["Image image", + "float * animNormals", + "float * animVertices", + "unsigned char * boneIds", + "float * boneWeights", + "unsigned char * colors", + "unsigned short * indices", + "float * normals", + "float * tangents", + "float * texcoords", + "float * texcoords2", + "unsigned int * vboId", + "float * vertices", + "GlyphInfo * glyphs", + "Rectangle * recs", + "Texture2D texture", + "Transform * bindPose", + "BoneInfo * bones", + "Material * materials", + "int * meshMaterial", + "Mesh * meshes", + "Matrix transform", + "BoneInfo * bones", + "Transform ** framePoses", + "Rectangle source", + "rAudioBuffer * buffer", + "rAudioProcessor * processor", + "void * data", + "float[4] chromaAbCorrection", + "float[4] lensDistortionValues", + "Color color", + "Texture2D texture", + "void * ctxData", + "AudioStream stream", + "void * data", + "Texture depth", + "Texture texture", + "Vector3 direction", + "Vector3 position", + "Vector3 normal", + "Vector3 point", + "Vector3 position", + "Vector3 target", + "Vector3 up", + "AudioStream stream", + "int * locs", + "float[2] leftLensCenter", + "float[2] leftScreenCenter", + "Matrix[2] projection", + "float[2] rightLensCenter", + "float[2] rightScreenCenter", + "float[2] scale", + "float[2] scaleIn", + "Matrix[2] viewOffset", + "MaterialMap * maps", + "float[4] params", + "Shader shader", + "Vector3 max", + "Vector3 min", + "char[32] name", + "Vector2 offset", + "Vector2 target", + "Quaternion rotation", + "Vector3 scale", + "Vector3 translation"] + +["unsigned char a", + "unsigned char b", + "unsigned char g", + "unsigned char r", + "int advanceX", + "int offsetX", + "int offsetY", + "int value", + "int triangleCount", + "unsigned int vaoId", + "int vertexCount", + "int baseSize", + "int glyphCount", + "int glyphPadding", + "int boneCount", + "int materialCount", + "int meshCount", + "int boneCount", + "int frameCount", + "int bottom", + "int layout", + "int left", + "int right", + "int top", + "unsigned int channels", + "unsigned int sampleRate", + "unsigned int sampleSize", + "unsigned int channels", + "unsigned int frameCount", + "unsigned int sampleRate", + "unsigned int sampleSize", + "float eyeToScreenDistance", + "int hResolution", + "float hScreenSize", + "float interpupillaryDistance", + "float lensSeparationDistance", + "int vResolution", + "float vScreenCenter", + "float vScreenSize", + "float value", + "int ctxType", + "unsigned int frameCount", + "bool looping", + "int format", + "int height", + "int mipmaps", + "int width", + "unsigned int id", + "float distance", + "bool hit", + "int format", + "int height", + "unsigned int id", + "int mipmaps", + "int width", + "float fovy", + "int projection", + "unsigned int frameCount", + "float height", + "float width", + "float x", + "float y", + "unsigned int id", + "float m0", + "float m1", + "float m10", + "float m11", + "float m12", + "float m13", + "float m14", + "float m15", + "float m2", + "float m3", + "float m4", + "float m5", + "float m6", + "float m7", + "float m8", + "float m9", + "int parent", + "float rotation", + "float zoom", + "float w", + "float x", + "float y", + "float z", + "float x", + "float y", + "float x", + "float y", + "float z"] +*/ diff --git a/src/core.c b/src/core.c deleted file mode 100644 index aa8a132..0000000 --- a/src/core.c +++ /dev/null @@ -1,168 +0,0 @@ -#include "mruby-raylib/core.h" -#include "mruby-raylib/types.h" -#include <raylib.h> - -/* - * @overload init_window(width: 800, height: 600, title: "Hello World from Raylib!") - * @param width [Integer] - * @param height [Integer] - * @param title [String] - */ -static mrb_value -mrb_init_window(mrb_state* mrb, mrb_value self) { - mrb_int screenWidth = 800; - mrb_int screenHeight = 600; - char* title = "Hello World from Raylib!"; - - uint32_t kw_num = 3; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "width"), - mrb_intern_lit(mrb, "height"), - mrb_intern_lit(mrb, "title"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|iiz:", &screenWidth, &screenHeight, &title, &kwargs); - - if (mrb_undef_p(kw_values[0])) { - kw_values[0] = mrb_fixnum_value(screenWidth); - } - if (mrb_undef_p(kw_values[1])) { - kw_values[1] = mrb_fixnum_value(screenHeight); - } - if (mrb_undef_p(kw_values[2])) { - kw_values[2] = mrb_str_new_cstr(mrb, title); - } - - InitWindow(mrb_fixnum(kw_values[0]), mrb_fixnum(kw_values[1]), mrb_str_to_cstr(mrb, kw_values[2])); - - return mrb_nil_value(); -} - - -/* - * Check if KEY_ESCAPE pressed or Close icon pressed - * @overload should_window_close?() - */ -static mrb_value -mrb_window_should_close(mrb_state* mrb, mrb_value self) { - return mrb_bool_value(WindowShouldClose()); -} - -/* - * Set background color *(framebuffer clear color)* - * @overload clear_background(color: Rl:Color.raywhite) - * @param color [Rl::Color] - * @return [Nil] - */ -static mrb_value -mrb_clear_background(mrb_state* mrb, mrb_value self) { - struct RClass *raylib = mrb_module_get(mrb, "Raylib"); - struct RClass *color = mrb_class_get_under(mrb, raylib, Color_type.struct_name); - mrb_value color_obj = mrb_funcall(mrb, mrb_obj_value(color), "ray_white", 0); - - uint32_t kw_num = 1; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "color"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|o:", &color_obj, &kwargs); - - if (!mrb_undef_p(kw_values[0])) { - color_obj = kw_values[0]; - } - - Color *color_data; - UNWRAPSTRUCT(Color, Color_type, color_obj, color_data); - - ClearBackground(*color_data); - return mrb_nil_value(); -} - -/* - * Setup canvas (framebuffer) to start drawing - * @return [Nil] - */ -static mrb_value -mrb_begin_drawing(mrb_state* mrb, mrb_value self) { - BeginDrawing(); - return mrb_nil_value(); -} - -/* - * End canvas drawing and swap buffers (double buffering) - * @return [Nil] - */ -static mrb_value -mrb_end_drawing(mrb_state* mrb, mrb_value self) { - EndDrawing(); - return mrb_nil_value(); -} -/* - * Begin scissor mode (define screen area for following drawing) - * @overload begin_scissor_mode(x: 0, y: 0, width: 10, height: 10) - * @param x [Integer] - * @param y [Integer] - * @param width [Integer] - * @param height [Integer] - * @return [Nil] - */ -static mrb_value -mrb_begin_scissor_mode(mrb_state* mrb, mrb_value self) { - mrb_int x = 0; - mrb_int y = 0; - mrb_int width = 10; - mrb_int height = 10; - //mrb_get_args(mrb, "iiii", &x, &y, &width, &height); - - - uint32_t kw_num = 4; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "x"), - mrb_intern_lit(mrb, "y"), - mrb_intern_lit(mrb, "width"), - mrb_intern_lit(mrb, "height"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|iiii:", &x, &y, &width, &height, &kwargs); - - if (mrb_undef_p(kw_values[0]) && mrb_undef_p(kw_values[1]) && mrb_undef_p(kw_values[2]) && mrb_undef_p(kw_values[3])) { - // pass params to kwargs - kw_values[0] = mrb_fixnum_value(x); - kw_values[1] = mrb_fixnum_value(y); - kw_values[2] = mrb_fixnum_value(width); - kw_values[3] = mrb_fixnum_value(height); - } else { - kw_values[0] = mrb_ensure_int_type(mrb, kw_values[0]); - kw_values[1] = mrb_ensure_int_type(mrb, kw_values[1]); - kw_values[2] = mrb_ensure_int_type(mrb, kw_values[2]); - kw_values[3] = mrb_ensure_int_type(mrb, kw_values[3]); - } - BeginScissorMode(mrb_fixnum(kw_values[0]), mrb_fixnum(kw_values[1]), mrb_fixnum(kw_values[2]), mrb_fixnum(kw_values[3])); - return mrb_nil_value(); -} - -/* - * End scissor mode - * @overload end_scissor_mode - * @return [Nil] - */ -static mrb_value -mrb_end_scissor_mode(mrb_state* mrb, mrb_value self) { - EndScissorMode(); - return mrb_nil_value(); -} - -void -mrb_init_raylib_core(mrb_state* mrb) { - struct RClass *raylib = mrb_define_module(mrb, "Raylib"); - mrb_define_module_function(mrb, raylib, "init_window", mrb_init_window, MRB_ARGS_OPT(3)); - mrb_define_module_function(mrb, raylib, "window_should_close?", mrb_window_should_close, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "clear_background", mrb_clear_background, MRB_ARGS_OPT(1)); - mrb_define_module_function(mrb, raylib, "begin_drawing", mrb_begin_drawing, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "end_drawing", mrb_end_drawing, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "begin_scissor_mode", mrb_begin_scissor_mode, MRB_ARGS_REQ(4)); - mrb_define_module_function(mrb, raylib, "end_scissor_mode", mrb_end_scissor_mode, MRB_ARGS_NONE()); -} diff --git a/src/raylib.c b/src/raylib.c deleted file mode 100644 index 2ab20d9..0000000 --- a/src/raylib.c +++ /dev/null @@ -1,1053 +0,0 @@ -#include "mruby-raylib/types.h" -#include "mruby-raylib/core.h" -#include "mruby-raylib/textures.h" -#include "mruby-raylib/text.h" -#include <raylib.h> -#include <mruby/array.h> -#include <mruby/class.h> -#include <mruby/numeric.h> -#include <mruby/string.h> -#include <stdlib.h> -#if defined(PLATFORM_WEB) -#include <emscripten/emscripten.h> -#endif - -#if defined(PLATFORM_WEB) -void execute_emscripten_block(void*); -#endif - -bool check_collision_circle_rec(mrb_state* mrb, mrb_value circle_obj, mrb_value rec_obj); - - - - -static mrb_value -mrb_NPatchInfo_initialize(mrb_state* mrb, mrb_value self) { - mrb_value rect_source_obj; - mrb_int left = 10; - mrb_int top = 10; - mrb_int right = 10; - mrb_int bottom = 10; - mrb_int layout = NPATCH_NINE_PATCH; - mrb_get_args(mrb, "o|iiiii", &rect_source_obj, &left, &top, &right, &bottom, &layout); - - NPatchInfo *npatch_info = (NPatchInfo *)DATA_PTR(self); - if(npatch_info) { mrb_free(mrb, npatch_info ); } - mrb_data_init(self, NULL, &NPatchInfo_type); - npatch_info = (NPatchInfo *)mrb_malloc(mrb, sizeof(NPatchInfo)); - - Rectangle *rect_source = DATA_GET_PTR(mrb, rect_source_obj, &Rectangle_type, Rectangle); - - npatch_info->source = *rect_source; - npatch_info->left = left; - npatch_info->top = top; - npatch_info->right = right; - npatch_info->bottom = bottom; - npatch_info->layout = layout; - - mrb_data_init(self, npatch_info, &NPatchInfo_type); - return self; -} - -/* accessors probably not needed - static mrb_value - mrb_NPatchInfo_get_source_rec(mrb_state* mrb, mrb_value self) { - NPatchInfo *npi = DATA_GET_PTR(mrb, self, &NPatchInfo_type, NPatchInfo); - struct RClass *c = mrb_module_get(mrb, "Raylib"); - struct RClass *rec_class = mrb_class_get_under(mrb, c, Rectangle_type.struct_name); - return mrb_obj_value(Data_Wrap_Struct(mrb, rec_class, &Rectangle_type, &npi->source)); - } - - static mrb_value - mrb_NPatchInfo_get_left(mrb_state* mrb, mrb_value self) { - NPatchInfo *npi = DATA_GET_PTR(mrb, self, &NPatchInfo_type, NPatchInfo); - return mrb_fixnum_value(npi->left); - } - - static mrb_value - mrb_NPatchInfo_get_top(mrb_state* mrb, mrb_value self) { - NPatchInfo *npi = DATA_GET_PTR(mrb, self, &NPatchInfo_type, NPatchInfo); - return mrb_fixnum_value(npi->top); - } - - static mrb_value - mrb_NPatchInfo_get_right(mrb_state* mrb, mrb_value self) { - NPatchInfo *npi = DATA_GET_PTR(mrb, self, &NPatchInfo_type, NPatchInfo); - return mrb_fixnum_value(npi->right); - } - - static mrb_value - mrb_NPatchInfo_get_bottom(mrb_state* mrb, mrb_value self) { - NPatchInfo *npi = DATA_GET_PTR(mrb, self, &NPatchInfo_type, NPatchInfo); - return mrb_fixnum_value(npi->bottom); - } - - static mrb_value - mrb_NPatchInfo_get_layout(mrb_state* mrb, mrb_value self) { - NPatchInfo *npi = DATA_GET_PTR(mrb, self, &NPatchInfo_type, NPatchInfo); - return mrb_fixnum_value(npi->layout); - }*/ - -static mrb_value -mrb_Rectangle_initialize(mrb_state* mrb, mrb_value self) { - mrb_float x = 0.0; - mrb_float y = 0.0; - mrb_float w = 10.0; - mrb_float h = 10.0; - mrb_get_args(mrb, "|ffff", &x, &y, &w, &h); - - Rectangle *rectangle = (Rectangle *)DATA_PTR(self); - if(rectangle) { mrb_free(mrb, rectangle); } - mrb_data_init(self, NULL, &Rectangle_type); - rectangle = (Rectangle *)mrb_malloc(mrb, sizeof(Rectangle)); - - rectangle->x = x; - rectangle->y = y; - rectangle->width = w; - rectangle->height= h; - - mrb_data_init(self, rectangle, &Rectangle_type); - return self; -} - -static mrb_value -mrb_Rectangle_get_x(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - return mrb_fixnum_value(rect->x); -} - -static mrb_value -mrb_Rectangle_set_x(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - mrb_float x; - mrb_get_args(mrb, "f", &x); - rect->x = x; - return mrb_fixnum_value(rect->x); -} - -static mrb_value -mrb_Rectangle_get_y(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - return mrb_fixnum_value(rect->y); -} - -static mrb_value -mrb_Rectangle_set_y(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - mrb_float y; - mrb_get_args(mrb, "f", &y); - rect->y = y; - return mrb_fixnum_value(rect->y); -} - -static mrb_value -mrb_Rectangle_get_width(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - return mrb_fixnum_value(rect->width); -} - -static mrb_value -mrb_Rectangle_set_width(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - mrb_float width; - mrb_get_args(mrb, "f", &width); - rect->x = width; - return mrb_fixnum_value(rect->width); -} - -static mrb_value -mrb_Rectangle_set_height(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - mrb_float height; - mrb_get_args(mrb, "f", &height); - rect->x = height; - return mrb_fixnum_value(rect->height); -} - -static mrb_value -mrb_Rectangle_get_height(mrb_state* mrb, mrb_value self) { - Rectangle *rect = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - return mrb_fixnum_value(rect->height); -} - -static mrb_value -mrb_Vector2_initialize(mrb_state* mrb, mrb_value self) { - mrb_float x = 1.0; - mrb_float y = 1.0; - mrb_get_args(mrb, "|ff", &x, &y); - - Vector2 *vector2 = (Vector2 *)DATA_PTR(self); - if(vector2) { mrb_free(mrb, vector2); } - mrb_data_init(self, NULL, &Vector2_type); - vector2 = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); - - vector2->x = x; - vector2->y = y; - - mrb_data_init(self, vector2, &Vector2_type); - return self; -} - -static mrb_value -mrb_Vector2_get_x(mrb_state* mrb, mrb_value self) { - Vector2 *vec2 = DATA_GET_PTR(mrb, self, &Vector2_type, Vector2); - return mrb_fixnum_value(vec2->x); -} - -static mrb_value -mrb_Vector2_set_x(mrb_state* mrb, mrb_value self) { - Vector2 *vec2 = DATA_GET_PTR(mrb, self, &Vector2_type, Vector2); - mrb_float x; - mrb_get_args(mrb, "f", &x); - vec2->x = x; - return mrb_fixnum_value(vec2->x); -} - -static mrb_value -mrb_Vector2_get_y(mrb_state* mrb, mrb_value self) { - Vector2 *vec2 = DATA_GET_PTR(mrb, self, &Vector2_type, Vector2); - return mrb_fixnum_value(vec2->y); -} - -static mrb_value -mrb_Vector2_set_y(mrb_state* mrb, mrb_value self) { - Vector2 *vec2 = DATA_GET_PTR(mrb, self, &Vector2_type, Vector2); - mrb_float y; - mrb_get_args(mrb, "f", &y); - vec2->y = y; - return mrb_fixnum_value(vec2->y); -} - -static mrb_value -mrb_Sound_initialize(mrb_state* mrb, mrb_value self) { - char* path = NULL; - mrb_get_args(mrb, "z", &path); - - Sound *sound = (Sound *)DATA_PTR(self); - if(sound) { mrb_free(mrb, sound); } - mrb_data_init(self, NULL, &Sound_type); - sound = (Sound *)mrb_malloc(mrb, sizeof(Sound)); - - *sound = LoadSound(path); - - mrb_data_init(self, sound, &Sound_type); - return self; -} - -static mrb_value -mrb_Sound_play(mrb_state* mrb, mrb_value self) { - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - PlaySound(*sound); - return mrb_nil_value(); -} - -static mrb_value -mrb_Sound_stop(mrb_state* mrb, mrb_value self) { - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - StopSound(*sound); - return mrb_nil_value(); -} - -static mrb_value -mrb_Sound_pause(mrb_state* mrb, mrb_value self) { - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - PauseSound(*sound); - return mrb_nil_value(); -} - -static mrb_value -mrb_Sound_resume(mrb_state* mrb, mrb_value self) { - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - ResumeSound(*sound); - return mrb_nil_value(); -} - -static mrb_value -mrb_Sound_set_volume(mrb_state* mrb, mrb_value self) { - mrb_float vol; - mrb_get_args(mrb, "f", &vol); - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - SetSoundVolume(*sound, vol); - return mrb_fixnum_value(vol); -} - -static mrb_value -mrb_Sound_set_pitch(mrb_state* mrb, mrb_value self) { - mrb_float pitch; - mrb_get_args(mrb, "f", &pitch); - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - SetSoundPitch(*sound, pitch); - return mrb_fixnum_value(pitch); -} - -static mrb_value -mrb_Sound_is_playing(mrb_state* mrb, mrb_value self) { - Sound *sound = DATA_GET_PTR(mrb, self, &Sound_type, Sound); - return mrb_bool_value(IsSoundPlaying(*sound)); -} - -static mrb_value -mrb_Music_initialize(mrb_state* mrb, mrb_value self) { - char* path = NULL; - mrb_get_args(mrb, "z", &path); - - Music *music = (Music *)DATA_PTR(self); - if(music) { mrb_free(mrb, music); } - mrb_data_init(self, NULL, &Music_type); - music = (Music *)mrb_malloc(mrb, sizeof(Music)); - - *music = LoadMusicStream(path); - - mrb_data_init(self, music, &Music_type); - return self; -} - -static mrb_value -mrb_Music_play(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - PlayMusicStream(*music); - return mrb_nil_value(); -} - -static mrb_value -mrb_Music_stop(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - StopMusicStream(*music); - return mrb_nil_value(); -} - -static mrb_value -mrb_Music_pause(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - PauseMusicStream(*music); - return mrb_nil_value(); -} - -static mrb_value -mrb_Music_resume(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - ResumeMusicStream(*music); - return mrb_nil_value(); -} - -static mrb_value -mrb_Music_is_playing(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - return mrb_bool_value(IsMusicStreamPlaying(*music)); -} - -static mrb_value -mrb_Music_set_volume(mrb_state* mrb, mrb_value self) { - mrb_float vol; - mrb_get_args(mrb, "f", &vol); - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - SetMusicVolume(*music, vol); - return mrb_fixnum_value(vol); -} - -static mrb_value -mrb_Music_set_pitch(mrb_state* mrb, mrb_value self) { - mrb_float pitch; - mrb_get_args(mrb, "f", &pitch); - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - SetMusicPitch(*music, pitch); - return mrb_fixnum_value(pitch); -} - -static mrb_value -mrb_Music_seek(mrb_state* mrb, mrb_value self) { - mrb_float pos; - mrb_get_args(mrb, "f", &pos); - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - SeekMusicStream(*music, pos); - return mrb_nil_value(); -} - -static mrb_value -mrb_Music_get_time_length(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - return mrb_fixnum_value(GetMusicTimeLength(*music)); -} - -static mrb_value -mrb_Music_get_time_played(mrb_state* mrb, mrb_value self) { - Music *music = DATA_GET_PTR(mrb, self, &Music_type, Music); - return mrb_fixnum_value(GetMusicTimePlayed(*music)); -} - - -static mrb_value -mrb_draw_texture_npatch(mrb_state* mrb, mrb_value self) { - mrb_value texture_obj; - mrb_value npi_obj; - mrb_value dest_rec_obj; - mrb_value pos_obj; - mrb_float rotation; - mrb_value tint_obj; - mrb_get_args(mrb, "oooofo", &texture_obj, &npi_obj, &dest_rec_obj, &pos_obj, &rotation, &tint_obj); - - Texture *texture_data = DATA_GET_PTR(mrb, texture_obj, &Texture_type, Texture); - NPatchInfo *npi_data = DATA_GET_PTR(mrb, npi_obj, &NPatchInfo_type, NPatchInfo); - Rectangle *dest_rec_data = DATA_GET_PTR(mrb, dest_rec_obj, &Rectangle_type, Rectangle); - Vector2 *pos_data = DATA_GET_PTR(mrb, pos_obj, &Vector2_type, Vector2); - Color *tint_data = DATA_GET_PTR(mrb, tint_obj, &Color_type, Color); - - DrawTextureNPatch(*texture_data, *npi_data, *dest_rec_data, *pos_data, rotation, *tint_data); - - return mrb_nil_value(); -} - -static mrb_value -mrb_begin_blend_mode(mrb_state* mrb, mrb_value self) { - mrb_int mode; - mrb_get_args(mrb, "i", &mode); - - BeginBlendMode(mode); - return mrb_nil_value(); -} - -static mrb_value -mrb_end_blend_mode(mrb_state* mrb, mrb_value self) { - EndBlendMode(); - return mrb_nil_value(); -} - - -static mrb_value -mrb_Color_initialize(mrb_state* mrb, mrb_value self) { - mrb_int r = 255; - mrb_int g = 0; - mrb_int b = 0; - mrb_int a = 255; - mrb_get_args(mrb, "|iiii", &r, &g, &b, &a); - - Color *color; - WRAPSTRUCT(Color, Color_type, self, color); - - color->r = r; - color->g = g; - color->b = b; - color->a = a; - - mrb_data_init(self, color, &Color_type); - return self; -} - -static mrb_value -mrb_Color_get_red(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - return mrb_fixnum_value(color->r); -} - -static mrb_value -mrb_Color_set_red(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - mrb_int r; - mrb_get_args(mrb, "i", &r); - color->r = r; - - return mrb_fixnum_value(color->r); -} - -static mrb_value -mrb_Color_get_green(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - return mrb_fixnum_value(color->g); -} - -static mrb_value -mrb_Color_set_green(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - mrb_int g; - mrb_get_args(mrb, "i", &g); - color->g = g; - - return mrb_fixnum_value(color->g); -} - -static mrb_value -mrb_Color_get_blue(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - - return mrb_fixnum_value(color->b); -} - -static mrb_value -mrb_Color_set_blue(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - mrb_int b; - mrb_get_args(mrb, "i", &b); - color->b = b; - - return mrb_fixnum_value(color->b); -} - -static mrb_value -mrb_Color_get_alpha(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - return mrb_fixnum_value(color->a); -} - -static mrb_value -mrb_Color_set_alpha(mrb_state* mrb, mrb_value self) { - Color *color; - UNWRAPSTRUCT(Color, Color_type, self, color); - mrb_int a; - mrb_get_args(mrb, "i", &a); - color->a = a; - - return mrb_fixnum_value(color->a); -} - -static mrb_value -mrb_is_mouse_button_pressed(mrb_state* mrb, mrb_value self) { - mrb_int button; - mrb_get_args(mrb, "i", &button); - - return mrb_bool_value(IsMouseButtonPressed(button)); -} - -static mrb_value -mrb_is_mouse_button_down(mrb_state* mrb, mrb_value self) { - mrb_int button; - mrb_get_args(mrb, "i", &button); - - return mrb_bool_value(IsMouseButtonDown(button)); -} - -static mrb_value -mrb_is_mouse_button_released(mrb_state* mrb, mrb_value self) { - mrb_int button; - mrb_get_args(mrb, "i", &button); - - return mrb_bool_value(IsMouseButtonReleased(button)); -} - -static mrb_value -mrb_is_mouse_button_up(mrb_state* mrb, mrb_value self) { - mrb_int button; - mrb_get_args(mrb, "i", &button); - - return mrb_bool_value(IsMouseButtonUp(button)); -} - -static mrb_value -mrb_is_key_pressed(mrb_state* mrb, mrb_value self) { - mrb_int key; - mrb_get_args(mrb, "i", &key); - - return mrb_bool_value(IsKeyPressed(key)); -} - -static mrb_value -mrb_is_key_down(mrb_state* mrb, mrb_value self) { - mrb_int key; - mrb_get_args(mrb, "i", &key); - - return mrb_bool_value(IsKeyDown(key)); -} - - -static mrb_value -mrb_is_key_released(mrb_state* mrb, mrb_value self) { - mrb_int key; - mrb_get_args(mrb, "i", &key); - - return mrb_bool_value(IsKeyReleased(key)); -} - -static mrb_value -mrb_is_key_up(mrb_state* mrb, mrb_value self) { - mrb_int key; - mrb_get_args(mrb, "i", &key); - - return mrb_bool_value(IsKeyUp(key)); -} - -static mrb_value -mrb_get_key_pressed(mrb_state* mrb, mrb_value self) { - return mrb_fixnum_value(GetKeyPressed()); -} - -static mrb_value -mrb_get_mouse_x(mrb_state* mrb, mrb_value self) { - return mrb_fixnum_value(GetMouseX()); -} - -static mrb_value -mrb_get_mouse_y(mrb_state* mrb, mrb_value self) { - return mrb_fixnum_value(GetMouseY()); -} - -static mrb_value -mrb_get_mouse_position(mrb_state* mrb, mrb_value self) { - Vector2 *pos = (Vector2 *)mrb_malloc(mrb, sizeof(Vector2)); - *pos = GetMousePosition(); - struct RClass *c = mrb_module_get(mrb, "Raylib"); - struct RClass *vec_class = mrb_class_get_under(mrb, c, Vector2_type.struct_name); - return mrb_obj_value(Data_Wrap_Struct(mrb, vec_class, &Vector2_type, pos)); -} - -static mrb_value -mrb_get_mouse_wheel_move(mrb_state* mrb, mrb_value self) { - return mrb_float_value(mrb, GetMouseWheelMove()); -} - -static mrb_value -mrb_init_audio_device(mrb_state* mrb, mrb_value self) { - InitAudioDevice(); - - return mrb_nil_value(); -} - -static mrb_value -mrb_is_audio_device_ready(mrb_state* mrb, mrb_value self) { - return mrb_bool_value(IsAudioDeviceReady()); -} - -static mrb_value -mrb_close_audio_device(mrb_state* mrb, mrb_value self) { - CloseAudioDevice(); - - return mrb_nil_value(); -} - -static mrb_value -mrb_set_master_volume(mrb_state* mrb, mrb_value self) { - mrb_float volume; - mrb_get_args(mrb, "f", &volume); - SetMasterVolume(volume); - return mrb_nil_value(); -} - -/* - * Returns a string telling if the platform is web or desktop. - * - * *Returns:* - * - * * +String+—Either "web" or "desktop". - */ -static mrb_value -mrb_platform(mrb_state* mrb, mrb_value self) { -#if defined(PLATFORM_WEB) - return mrb_str_new_lit(mrb, "web"); -#else - return mrb_str_new_lit(mrb, "desktop"); -#endif -} - -//void DrawText(const char *text, int posX, int posY, int fontSize, Color color); -static mrb_value -mrb_draw_text(mrb_state* mrb, mrb_value self) { - char* text = "Default Text"; - mrb_int x = 0; - mrb_int y = 0; - mrb_int fontSize = 16; - mrb_value color_obj; - - - mrb_get_args(mrb, "|ziiio", &text, &x, &y, &fontSize, &color_obj); - Color *color; - UNWRAPSTRUCT(Color, Color_type, color_obj, color); - DrawText(text, x, y, fontSize, *color); - return mrb_nil_value(); -} - -static mrb_value -mrb_call_main_loop(mrb_state* mrb, mrb_value self) { - struct RClass *c = mrb_module_get(mrb, "Raylib"); - return mrb_funcall(mrb, mrb_obj_value(c), "main_loop", 0); -} - -#if defined(PLATFORM_WEB) -static mrb_value -mrb_emscripten_set_main_loop(mrb_state* mrb, mrb_value self) { - emscripten_set_main_loop_arg(execute_emscripten_block, mrb, 0, 1); - return mrb_nil_value(); -} - -void -execute_emscripten_block(void* mrb) { - struct RClass *c = mrb_module_get(mrb, "Raylib"); - mrb_funcall(mrb, mrb_obj_value(c), "main_loop", 0); -} -#endif - -static mrb_value -mrb_target_fps(mrb_state* mrb, mrb_value self) { - mrb_int fps = 60; - mrb_get_args(mrb, "i", &fps); - SetTargetFPS(fps); - return mrb_nil_value(); -} - -static mrb_value -mrb_fps(mrb_state* mrb, mrb_value self) { - return mrb_fixnum_value(GetFPS()); -} - -static mrb_value -mrb_frame_time(mrb_state* mrb, mrb_value self) { - return mrb_float_value(mrb, GetFrameTime()); -} - -static mrb_value -mrb_time(mrb_state* mrb, mrb_value self) { - return mrb_float_value(mrb, GetTime()); -} - -static mrb_value -mrb_Circle_collide_with_circ(mrb_state* mrb, mrb_value self) { - mrb_value circle_obj; - mrb_get_args(mrb, "o", &circle_obj); - - mrb_value vector_obj1 = mrb_funcall(mrb, self, "vector", 0); - Vector2 *center1 = DATA_GET_PTR(mrb, vector_obj1, &Vector2_type, Vector2); - mrb_float radius1 = mrb_as_float(mrb, mrb_funcall(mrb, self, "radius", 0)); - - mrb_value vector_obj2 = mrb_funcall(mrb, circle_obj, "vector", 0); - Vector2 *center2 = DATA_GET_PTR(mrb, vector_obj2, &Vector2_type, Vector2); - mrb_float radius2 = mrb_as_float(mrb, mrb_funcall(mrb, circle_obj, "radius", 0)); - - return mrb_bool_value(CheckCollisionCircles(*center1, radius1, *center2, radius2)); -} - -static mrb_value -mrb_Rectangle_collide_with_rec(mrb_state* mrb, mrb_value self) { - mrb_value rec1_obj; - mrb_get_args(mrb, "o", &rec1_obj); - - Rectangle *rec1 = DATA_GET_PTR(mrb, rec1_obj, &Rectangle_type, Rectangle); - Rectangle *rec2 = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - - return mrb_bool_value(CheckCollisionRecs(*rec1, *rec2)); -} - -static mrb_value -mrb_Rectangle_collide_with_point(mrb_state* mrb, mrb_value self) { - mrb_value vec_obj; - mrb_get_args(mrb, "o", &vec_obj); - Vector2 *point = DATA_GET_PTR(mrb, vec_obj, &Vector2_type, Vector2); - Rectangle *rec_self = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - - return mrb_bool_value(CheckCollisionPointRec(*point, *rec_self)); -} - -bool -check_collision_circle_rec(mrb_state* mrb, mrb_value circle_obj, mrb_value rec_obj) { - mrb_value vector_obj = mrb_funcall(mrb, circle_obj, "vector", 0); - mrb_float radius = mrb_as_float(mrb, mrb_funcall(mrb, circle_obj, "radius", 0)); - Vector2 *center = DATA_GET_PTR(mrb, vector_obj, &Vector2_type, Vector2); - Rectangle *rec = DATA_GET_PTR(mrb, rec_obj, &Rectangle_type, Rectangle); - - return CheckCollisionCircleRec(*center, radius, *rec); -} - -static mrb_value -mrb_Rectangle_collide_with_circ(mrb_state* mrb, mrb_value self) { - mrb_value circle_obj; - mrb_get_args(mrb, "o", &circle_obj); - - return mrb_bool_value(check_collision_circle_rec(mrb, circle_obj, self)); -} - -static mrb_value -mrb_Circle_collide_with_rec(mrb_state* mrb, mrb_value self) { - mrb_value rec_obj; - mrb_get_args(mrb, "o", &rec_obj); - - return mrb_bool_value(check_collision_circle_rec(mrb, self, rec_obj)); -} - -static mrb_value -mrb_Rectangle_get_collision_rec(mrb_state* mrb, mrb_value self) { - mrb_value rec_obj; - mrb_get_args(mrb, "o", &rec_obj); - - Rectangle *rec_self = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - Rectangle *rec_other = DATA_GET_PTR(mrb, rec_obj, &Rectangle_type, Rectangle); - Rectangle *collision_rec = (Rectangle *)mrb_malloc(mrb, sizeof(Rectangle)); - *collision_rec = GetCollisionRec(*rec_self, *rec_other); - - struct RClass *c = mrb_module_get(mrb, "Raylib"); - struct RClass *rec_class = mrb_class_get_under(mrb, c, Rectangle_type.struct_name); - return mrb_obj_value(Data_Wrap_Struct(mrb, rec_class, &Rectangle_type, collision_rec)); -} - -static mrb_value -mrb_draw_poly(mrb_state* mrb, mrb_value self) { - // void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) - Vector2 center = {0}; - int sides = 3; - float radius = 100; - float rotation = 0; - Color color = WHITE; - - uint32_t kw_num = 5; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "center"), - mrb_intern_lit(mrb, "sides"), - mrb_intern_lit(mrb, "radius"), - mrb_intern_lit(mrb, "rotation"), - mrb_intern_lit(mrb, "color"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|:", &kwargs); - - //center - if (!(mrb_undef_p(kw_values[0]))) { - Vector2 *vector2_data; - UNWRAPSTRUCT(Vector2, Vector2_type, kw_values[0], vector2_data); - center = *vector2_data; - } - - // sides - if (!(mrb_undef_p(kw_values[1]))) { - sides = mrb_as_int(mrb, kw_values[1]); - } - - // radius - if (!(mrb_undef_p(kw_values[2]))) { - radius = mrb_as_float(mrb, kw_values[2]); - } - - // rotation - if (!mrb_undef_p(kw_values[3])) { - rotation = mrb_as_float(mrb, kw_values[3]) / 0.017453; - } - - // color - if (!mrb_undef_p(kw_values[4])) { - Color *color_data; - UNWRAPSTRUCT(Color, Color_type, kw_values[4], color_data); - color = *color_data; - } - - DrawPoly(center, sides, radius, rotation, color); - return mrb_nil_value(); -} - -static mrb_value -mrb_draw_poly_lines(mrb_state* mrb, mrb_value self) { - // void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) - Vector2 center = {0}; - int sides = 3; - float radius = 100; - float rotation = 0; - float line_thickness = 1; - Color color = WHITE; - - uint32_t kw_num = 6; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "center"), - mrb_intern_lit(mrb, "sides"), - mrb_intern_lit(mrb, "radius"), - mrb_intern_lit(mrb, "rotation"), - mrb_intern_lit(mrb, "line_thickness"), - mrb_intern_lit(mrb, "color"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|:", &kwargs); - - //center - if (!(mrb_undef_p(kw_values[0]))) { - Vector2 *vector2_data; - UNWRAPSTRUCT(Vector2, Vector2_type, kw_values[0], vector2_data); - center = *vector2_data; - } - - // sides - if (!(mrb_undef_p(kw_values[1]))) { - sides = mrb_as_int(mrb, kw_values[1]); - } - - // radius - if (!(mrb_undef_p(kw_values[2]))) { - radius = mrb_as_float(mrb, kw_values[2]); - } - - // rotation - if (!mrb_undef_p(kw_values[3])) { - rotation = mrb_as_float(mrb, kw_values[3]) / 0.017453; - } - - // line_thickness - if (!mrb_undef_p(kw_values[4])) { - line_thickness = mrb_as_float(mrb, kw_values[4]); - } - - // color - if (!mrb_undef_p(kw_values[5])) { - Color *color_data; - UNWRAPSTRUCT(Color, Color_type, kw_values[5], color_data); - color = *color_data; - } - - DrawPolyLinesEx(center, sides, radius, rotation, line_thickness, color); - return mrb_nil_value(); -} - -static mrb_value -mrb_Rectangle_draw_rectangle_rec(mrb_state* mrb, mrb_value self) { - mrb_value color_obj; - mrb_get_args(mrb, "o", &color_obj); - - Color *color; - UNWRAPSTRUCT(Color, Color_type, color_obj, color); - Rectangle *rec_self = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - DrawRectangleRec(*rec_self, *color); - - return mrb_nil_value(); -} - -static mrb_value -mrb_Rectangle_draw_rectangle_lines_ex(mrb_state* mrb, mrb_value self) { - mrb_value color_obj; - mrb_float line_thick; - mrb_get_args(mrb, "fo", &line_thick, &color_obj); - - Color *color; - UNWRAPSTRUCT(Color, Color_type, color_obj, color); - Rectangle *rec_self = DATA_GET_PTR(mrb, self, &Rectangle_type, Rectangle); - DrawRectangleLinesEx(*rec_self, line_thick, *color); - - return mrb_nil_value(); -} - -void -mrb_mruby_raylib_gem_init(mrb_state* mrb) { - mrb_init_raylib_core(mrb); - mrb_init_raylib_textures(mrb); - mrb_init_raylib_text(mrb); - - struct RClass *raylib = mrb_define_module(mrb, "Raylib"); - mrb_define_module_function(mrb, raylib, "platform", mrb_platform, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "_draw_text", mrb_draw_text, MRB_ARGS_OPT(5)); - mrb_define_module_function(mrb, raylib, "call_main_loop", mrb_call_main_loop, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "target_fps=", mrb_target_fps, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "fps", mrb_fps, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "frame_time", mrb_frame_time, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "time", mrb_time, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "mouse_button_pressed?", mrb_is_mouse_button_pressed, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "mouse_button_down?", mrb_is_mouse_button_down, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "mouse_button_released?", mrb_is_mouse_button_released, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "mouse_button_up?", mrb_is_mouse_button_up, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "key_pressed?", mrb_is_key_pressed, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "key_down?", mrb_is_key_down, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "key_released?", mrb_is_key_released, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "key_up?", mrb_is_key_up, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "_next_key_pressed", mrb_get_key_pressed, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "mouse_x", mrb_get_mouse_x, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "mouse_y", mrb_get_mouse_y, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "mouse_position", mrb_get_mouse_position, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "mouse_wheel", mrb_get_mouse_wheel_move, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "begin_blend_mode", mrb_begin_blend_mode, MRB_ARGS_REQ(1)); - mrb_define_module_function(mrb, raylib, "end_blend_mode", mrb_end_blend_mode, MRB_ARGS_NONE()); - - struct RClass *color_class = mrb_define_class_under(mrb, raylib, "Color", mrb->object_class); - MRB_SET_INSTANCE_TT(color_class, MRB_TT_DATA); - mrb_define_method(mrb, color_class, "initialize", mrb_Color_initialize, MRB_ARGS_OPT(4)); - mrb_define_method(mrb, color_class, "r", mrb_Color_get_red, MRB_ARGS_NONE()); - mrb_define_method(mrb, color_class, "r=", mrb_Color_set_red, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, color_class, "g", mrb_Color_get_green, MRB_ARGS_NONE()); - mrb_define_method(mrb, color_class, "g=", mrb_Color_set_green, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, color_class, "b", mrb_Color_get_blue, MRB_ARGS_NONE()); - mrb_define_method(mrb, color_class, "b=", mrb_Color_set_blue, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, color_class, "a", mrb_Color_get_alpha, MRB_ARGS_NONE()); - mrb_define_method(mrb, color_class, "a=", mrb_Color_set_alpha, MRB_ARGS_REQ(1)); - - mrb_define_module_function(mrb, raylib, "init_audio_device", mrb_init_audio_device, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "audio_device_ready?", mrb_is_audio_device_ready, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "close_audio_device", mrb_close_audio_device, MRB_ARGS_NONE()); - mrb_define_module_function(mrb, raylib, "set_master_volume", mrb_set_master_volume, MRB_ARGS_REQ(1)); - - struct RClass *sound_class = mrb_define_class_under(mrb, raylib, "Sound", mrb->object_class); - MRB_SET_INSTANCE_TT(sound_class, MRB_TT_DATA); - mrb_define_method(mrb, sound_class, "initialize", mrb_Sound_initialize, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, sound_class, "play", mrb_Sound_play, MRB_ARGS_NONE()); - mrb_define_method(mrb, sound_class, "stop", mrb_Sound_stop, MRB_ARGS_NONE()); - mrb_define_method(mrb, sound_class, "pause", mrb_Sound_pause, MRB_ARGS_NONE()); - mrb_define_method(mrb, sound_class, "resume", mrb_Sound_resume, MRB_ARGS_NONE()); - mrb_define_method(mrb, sound_class, "volume=", mrb_Sound_set_volume, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, sound_class, "pitch=", mrb_Sound_set_pitch, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, sound_class, "playing?", mrb_Sound_is_playing, MRB_ARGS_NONE()); - - struct RClass *music_class = mrb_define_class_under(mrb, raylib, "Music", mrb->object_class); - MRB_SET_INSTANCE_TT(music_class, MRB_TT_DATA); - mrb_define_method(mrb, music_class, "initialize", mrb_Music_initialize, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, music_class, "play", mrb_Music_play, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "stop", mrb_Music_stop, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "pause", mrb_Music_pause, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "resume", mrb_Music_resume, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "volume=", mrb_Music_set_volume, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, music_class, "pitch=", mrb_Music_set_pitch, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, music_class, "seek", mrb_Music_seek, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, music_class, "playing?", mrb_Music_is_playing, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "time_length", mrb_Music_get_time_length, MRB_ARGS_NONE()); - mrb_define_method(mrb, music_class, "time_played", mrb_Music_get_time_played, MRB_ARGS_NONE()); - - struct RClass *vector2_class = mrb_define_class_under(mrb, raylib, "Vector2", mrb->object_class); - MRB_SET_INSTANCE_TT(vector2_class, MRB_TT_DATA); - mrb_define_method(mrb, vector2_class, "initialize", mrb_Vector2_initialize, MRB_ARGS_OPT(2)); - mrb_define_method(mrb, vector2_class, "x", mrb_Vector2_get_x, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "x=", mrb_Vector2_set_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, vector2_class, "y", mrb_Vector2_get_y, MRB_ARGS_NONE()); - mrb_define_method(mrb, vector2_class, "y=", mrb_Vector2_set_y, MRB_ARGS_REQ(1)); - - struct RClass *rectangle_class = mrb_define_class_under(mrb, raylib, "Rectangle", mrb->object_class); - MRB_SET_INSTANCE_TT(rectangle_class, MRB_TT_DATA); - mrb_define_method(mrb, rectangle_class, "initialize", mrb_Rectangle_initialize, MRB_ARGS_OPT(4)); - mrb_define_method(mrb, rectangle_class, "x", mrb_Rectangle_get_x, MRB_ARGS_NONE()); - mrb_define_method(mrb, rectangle_class, "x=", mrb_Rectangle_set_x, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "y", mrb_Rectangle_get_y, MRB_ARGS_NONE()); - mrb_define_method(mrb, rectangle_class, "y=", mrb_Rectangle_set_y, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "width", mrb_Rectangle_get_width, MRB_ARGS_NONE()); - mrb_define_method(mrb, rectangle_class, "width=", mrb_Rectangle_set_width, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "w", mrb_Rectangle_get_width, MRB_ARGS_NONE()); - mrb_define_method(mrb, rectangle_class, "w=", mrb_Rectangle_set_width, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "height", mrb_Rectangle_get_height, MRB_ARGS_NONE()); - mrb_define_method(mrb, rectangle_class, "height=", mrb_Rectangle_set_height, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "h", mrb_Rectangle_get_height, MRB_ARGS_NONE()); - mrb_define_method(mrb, rectangle_class, "h=", mrb_Rectangle_set_height, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "collision_rec", mrb_Rectangle_get_collision_rec, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "collide_with_rec?", mrb_Rectangle_collide_with_rec, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "collide_with_circle?", mrb_Rectangle_collide_with_circ, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "collide_with_point?", mrb_Rectangle_collide_with_point, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "_draw", mrb_Rectangle_draw_rectangle_rec, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, rectangle_class, "_draw_lines", mrb_Rectangle_draw_rectangle_lines_ex, MRB_ARGS_REQ(2)); - mrb_define_module_function(mrb, raylib, "draw_poly", mrb_draw_poly, MRB_ARGS_OPT(1)); - mrb_define_module_function(mrb, raylib, "draw_poly_lines", mrb_draw_poly_lines, MRB_ARGS_OPT(1)); - - struct RClass *circle_class = mrb_define_class_under(mrb, raylib, "Circle", mrb->object_class); - mrb_define_method(mrb, circle_class, "collide_with_rec?", mrb_Circle_collide_with_rec, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, circle_class, "collide_with_circle?", mrb_Circle_collide_with_circ, MRB_ARGS_REQ(1)); - - struct RClass *npatch_info_class = mrb_define_class_under(mrb, raylib, "NPatchInfo", mrb->object_class); - mrb_define_method(mrb, npatch_info_class, "initialize", mrb_NPatchInfo_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(5)); - /* accessors probably not needed - mrb_define_method(mrb, npatch_info_class, "source_rec", mrb_NPatchInfo_get_source_rec, MRB_ARGS_NONE()); - mrb_define_method(mrb, npatch_info_class, "left", mrb_NPatchInfo_get_left, MRB_ARGS_NONE()); - mrb_define_method(mrb, npatch_info_class, "top", mrb_NPatchInfo_get_top, MRB_ARGS_NONE()); - mrb_define_method(mrb, npatch_info_class, "right", mrb_NPatchInfo_get_right, MRB_ARGS_NONE()); - mrb_define_method(mrb, npatch_info_class, "bottom", mrb_NPatchInfo_get_bottom, MRB_ARGS_NONE()); - mrb_define_method(mrb, npatch_info_class, "layout", mrb_NPatchInfo_get_layout, MRB_ARGS_NONE());*/ - -#if defined(PLATFORM_WEB) - mrb_define_module_function(mrb, raylib, "emscripten_set_main_loop", mrb_emscripten_set_main_loop, MRB_ARGS_NONE()); -#endif -} - -void -mrb_mruby_raylib_gem_final(mrb_state* mrb) { - /* finalizer */ - if (IsWindowReady()) { CloseWindow(); }; -} diff --git a/src/text.c b/src/text.c deleted file mode 100644 index 8f51db1..0000000 --- a/src/text.c +++ /dev/null @@ -1,196 +0,0 @@ -/** - * @author : tradam (tradam@skyx4c-artix) - * @file : text - * @created : Wednesday Feb 09, 2022 07:30:48 EST - */ - -#include "mruby-raylib/text.h" -#include "mruby-raylib/types.h" -#include <raylib.h> -#include <mruby/class.h> - - -/* Create a new texture. - * @overload initialize(path:) - * @param path [String] File path to the texture to be loaded - * @return [Texture] - */ -static mrb_value -mrb_Font_initialize(mrb_state* mrb, mrb_value self) { - char* path; - - uint32_t kw_num = 2; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "path"), - mrb_intern_lit(mrb, "font_size"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|:", &kwargs); - - printf("wrapping struct"); - fflush(stdout); - Font *font; - WRAPSTRUCT(Font, Font_type, self, font); - - if(mrb_undef_p(kw_values[0])) { - *font = GetFontDefault(); - } else { - path = mrb_str_to_cstr(mrb, kw_values[0]); - if(mrb_undef_p(kw_values[1])) { - printf("default size"); - fflush(stdout); - *font = LoadFont(path); - } else { - printf("custom size"); - fflush(stdout); - *font = LoadFontEx(path, mrb_as_int(mrb, kw_values[1]), NULL, 95); - } - } - - mrb_data_init(self, font, &Font_type); - return self; -} - -/* - * Draw the string as text on the screen. - * @overload draw(x: 0, y: 0, origin: Rl::Vector2.default, rotation: 0, font_size: 20, spacing: font_size/10, font: Rl::Font.default) - * @param x [Integer] x position - * @param y [Integer] y position - * @param origin [Vector2] Offset - * @param rotation [Float] How much to rotate the text in radians - * @param font_size [Integer] - * @param spacing [Float] Spacing between letters - * @param font [Font] What font to render the text with - * @return [Nil] - */ -static mrb_value -mrb_String_draw_text(mrb_state* mrb, mrb_value self) { - int x = 0; - int y = 0; - float rotation = 0; - float font_size = 20.0; - float spacing = 10.0; - Font default_font = GetFontDefault(); - - uint32_t kw_num = 8; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "font"), - mrb_intern_lit(mrb, "x"), - mrb_intern_lit(mrb, "y"), - mrb_intern_lit(mrb, "origin"), - mrb_intern_lit(mrb, "rotation"), - mrb_intern_lit(mrb, "font_size"), - mrb_intern_lit(mrb, "spacing"), - mrb_intern_lit(mrb, "color"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|:", &kwargs); - - if (!mrb_undef_p(kw_values[0])){ - - Font *tmp_font; - UNWRAPSTRUCT(Font, Font_type, kw_values[0], tmp_font); - - default_font = *tmp_font; - } - - // x - if (!mrb_undef_p(kw_values[1])) { - x = mrb_as_int(mrb, kw_values[1]); - } - - // y - if (!mrb_undef_p(kw_values[2])) { - y = mrb_as_int(mrb, kw_values[2]); - } - - // origin - if (mrb_undef_p(kw_values[3])) { - struct RClass *raylib = mrb_module_get(mrb, "Raylib"); - struct RClass *vector2 = mrb_class_get_under(mrb, raylib, Vector2_type.struct_name); - kw_values[3] = mrb_funcall(mrb, mrb_obj_value(vector2), "default", 0); - } - - // rotation - if (!mrb_undef_p(kw_values[4])) { - rotation = mrb_as_float(mrb, kw_values[4]) / 0.017453; - } - - // font_size - if (!mrb_undef_p(kw_values[5])) { - font_size = mrb_as_float(mrb, kw_values[5]); - } - - // spacing - if (!mrb_undef_p(kw_values[6])) { - spacing = mrb_as_float(mrb, kw_values[6]); - } else { - spacing = font_size/10.0; - } - - // color - if (mrb_undef_p(kw_values[7])) { - struct RClass *raylib = mrb_module_get(mrb, "Raylib"); - struct RClass *color = mrb_class_get_under(mrb, raylib, Color_type.struct_name); - kw_values[7] = mrb_funcall(mrb, mrb_obj_value(color), "blue", 0); - } - - Color *tint_data; - UNWRAPSTRUCT(Color, Color_type, kw_values[7], tint_data); - - Vector2 *vector2_data; - UNWRAPSTRUCT(Vector2, Vector2_type, kw_values[3], vector2_data); - - Vector2 position = { x, y }; - - DrawTextPro(default_font, mrb_str_to_cstr(mrb, self), position, *vector2_data, rotation, font_size, spacing, *tint_data); - - return mrb_nil_value(); -} - -/* - * Draw the fps with a color depending on how high the fps is(30+ is green, 15-30 is orange, <15 is red). - * @return [Nil] - */ -static mrb_value -mrb_Raylib_draw_fps(mrb_state* mrb, mrb_value self) { - int x = 10; - int y = 10; - - uint32_t kw_num = 2; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "x"), - mrb_intern_lit(mrb, "y"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|:", &kwargs); - - // x - if (!mrb_undef_p(kw_values[0])) { - x = mrb_as_int(mrb, kw_values[0]); - } - - // y - if (!mrb_undef_p(kw_values[1])) { - y = mrb_as_int(mrb, kw_values[1]); - } - - DrawFPS(x, y); - return mrb_nil_value(); -} - - -void -mrb_init_raylib_text(mrb_state* mrb) { - struct RClass *raylib = mrb_define_module(mrb, "Raylib"); - struct RClass *string_extension = mrb_define_module_under(mrb, raylib, "StringExtension"); - struct RClass *font_class = mrb_define_class_under(mrb, raylib, "Font", mrb->object_class); - MRB_SET_INSTANCE_TT(font_class, MRB_TT_DATA); - mrb_define_method(mrb, font_class, "initialize", mrb_Font_initialize, MRB_ARGS_OPT(1)); - mrb_define_method(mrb, string_extension, "draw", mrb_String_draw_text, MRB_ARGS_OPT(1)); - mrb_define_module_function(mrb, raylib, "draw_fps", mrb_Raylib_draw_fps, MRB_ARGS_OPT(1)); -} - diff --git a/src/textures.c b/src/textures.c deleted file mode 100644 index 3a0b4bc..0000000 --- a/src/textures.c +++ /dev/null @@ -1,238 +0,0 @@ -#include "mruby-raylib/textures.h" -#include "mruby-raylib/types.h" -#include <raylib.h> -#include <mruby/class.h> - -/* Create a new texture. - * @overload initialize(path:) - * @param path [String] File path to the texture to be loaded - * @return [Texture] - */ -static mrb_value -mrb_Texture_initialize(mrb_state* mrb, mrb_value self) { - char* path; - - uint32_t kw_num = 1; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "path"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|z:", &path, &kwargs); - - if(!mrb_undef_p(kw_values[0])) { - path = mrb_str_to_cstr(mrb, kw_values[0]); - } - - Texture *texture; - WRAPSTRUCT(Texture, Texture_type, self, texture); - - *texture = LoadTexture(path); - - mrb_data_init(self, texture, &Texture_type); - return self; -} - -/* - * Get the width of a texture. - * @overload width - * @overload w - * @return [Integer] - */ -static mrb_value -mrb_Texture_get_width(mrb_state* mrb, mrb_value self) { - Texture *texture; - UNWRAPSTRUCT(Texture, Texture_type, self, texture); - return mrb_fixnum_value(texture->width); -} - -/* - * Set the width of a texture. - * @overload width=(width) - * @param width [Integer] The new width - * @overload w=(width) - * @param w [Integer] The new width - * @return [Integer] - */ -static mrb_value -mrb_Texture_set_width(mrb_state* mrb, mrb_value self) { - Texture *texture; - UNWRAPSTRUCT(Texture, Texture_type, self, texture); - mrb_int width; - mrb_get_args(mrb, "i", &width); - texture->width = width; - return mrb_fixnum_value(texture->width); -} - -/* - * Get the height of a texture. - * @overload height - * @overload h - * @return [Integer] - */ -static mrb_value -mrb_Texture_get_height(mrb_state* mrb, mrb_value self) { - Texture *texture; - UNWRAPSTRUCT(Texture, Texture_type, self, texture); - return mrb_fixnum_value(texture->height); -} - -/* - * Set the height of a texture. - * @overload height=(height) - * @param height [Integer] The new height - * @overload h=(height) - * @param h [Integer] The new height - * @return [Integer] - */ -static mrb_value -mrb_Texture_set_height(mrb_state* mrb, mrb_value self) { - Texture *texture; - UNWRAPSTRUCT(Texture, Texture_type, self, texture); - mrb_int height; - mrb_get_args(mrb, "i", &height); - texture->height = height; - return mrb_fixnum_value(texture->height); -} - -/* - * Get the id of a texture. - * @overload id - * @return [Integer] - */ -static mrb_value -mrb_Texture_get_id(mrb_state* mrb, mrb_value self) { - Texture *texture = DATA_GET_PTR(mrb, self, &Texture_type, Texture); - return mrb_fixnum_value(texture->id); -} - -/* - * Get the mipmaps of a texture. - * @overload mipmaps - * @return [Integer] - */ -/* - static mrb_value - mrb_Texture_get_mipmaps(mrb_state* mrb, mrb_value self) { - Texture *texture = DATA_GET_PTR(mrb, self, &Texture_type, Texture); - return mrb_fixnum_value(texture->mipmaps); - } - */ - -/* - * Get the format of a texture. - * @overload format - * @return [Integer] - */ -/* - static mrb_value - mrb_Texture_get_format(mrb_state* mrb, mrb_value self) { - Texture *texture = DATA_GET_PTR(mrb, self, &Texture_type, Texture); - return mrb_fixnum_value(texture->format); - } - */ - -/* - * Draw the texture - * @overload draw(source: Rl::Rectangle.new(0,0,texture.width,texture.height), dest: Rl::Rectangle.new(0,0,texture.width,texture.height), origin: Rl::Vector2.default, rotation: 0, tint: Rl::Color.white) - * @param tint [Color] The color the drawn texture is tinted(white is 'no tint'). - * @param source [Rectangle] Which section of the texture is to be drawn, the default is the entire texture. - * @param origin [Vector2] Offset of the drawn texture. Default is no offset. - * @param rotation [Float] How much the texture is rotated when drawn(In radians). - * @param dest [Rectangle] Where the texture is to be drawn on the screen(This can scale the texture). Default is the size of the texture. - * @return [Nil] - */ -static mrb_value -mrb_Texture_draw_texture(mrb_state* mrb, mrb_value self) { - struct RClass *raylib;// = mrb_module_get(mrb, "Raylib"); - Rectangle source = {0}; - Rectangle dest = {0}; - float rotation = 0.0; - Texture *texture_data; - UNWRAPSTRUCT(Texture, Texture_type, self, texture_data); - //mrb_value tint_obj = mrb_funcall(mrb, mrb_obj_value(color), "white", 0); - //Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint - uint32_t kw_num = 5; - const mrb_sym kw_names[] = { - mrb_intern_lit(mrb, "source"), - mrb_intern_lit(mrb, "dest"), - mrb_intern_lit(mrb, "origin"), - mrb_intern_lit(mrb, "rotation"), - mrb_intern_lit(mrb, "tint"), - }; - mrb_value kw_values[kw_num]; - const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; - mrb_get_args(mrb, "|:", &kwargs); - - // if source defined - if (!(mrb_undef_p(kw_values[0]))) { - Rectangle *temp_rec; - UNWRAPSTRUCT(Rectangle, Rectangle_type, kw_values[0], temp_rec); - source = *temp_rec; - } else { - source = (struct Rectangle){ 0, 0, texture_data->width, texture_data->height }; - } - - // if dest defined - if (!(mrb_undef_p(kw_values[1]))) { - Rectangle *temp_rec; - UNWRAPSTRUCT(Rectangle, Rectangle_type, kw_values[1], temp_rec); - dest = *temp_rec; - } else { - dest = (struct Rectangle){ 0, 0, texture_data->width, texture_data->height }; - } - - // if origin undefined - if ((mrb_undef_p(kw_values[2]))) { - raylib = mrb_module_get(mrb, "Raylib"); - struct RClass *vector2 = mrb_class_get_under(mrb, raylib, Vector2_type.struct_name); - kw_values[2] = mrb_funcall(mrb, mrb_obj_value(vector2), "default", 0); - } - - // if rotation defined - if (!(mrb_undef_p(kw_values[3]))) { - rotation = mrb_as_float(mrb, kw_values[3]) / 0.017453; - } - - // if color undefined - if ((mrb_undef_p(kw_values[4]))) { - raylib = mrb_module_get(mrb, "Raylib"); // needs to be called again or else segfault - struct RClass *color = mrb_class_get_under(mrb, raylib, Color_type.struct_name); - kw_values[4] = mrb_funcall(mrb, mrb_obj_value(color), "white", 0); - } - - - - Color *tint_data; - UNWRAPSTRUCT(Color, Color_type, kw_values[4], tint_data); - - Vector2 *vector2_data; - UNWRAPSTRUCT(Vector2, Vector2_type, kw_values[2], vector2_data); - - //Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint - DrawTexturePro(*texture_data, source, dest, *vector2_data, rotation, *tint_data); - - return mrb_nil_value(); -} - - -void -mrb_init_raylib_textures(mrb_state* mrb) { - struct RClass *raylib = mrb_define_module(mrb, "Raylib"); - struct RClass *texture_class = mrb_define_class_under(mrb, raylib, "Texture", mrb->object_class); - MRB_SET_INSTANCE_TT(texture_class, MRB_TT_DATA); - mrb_define_method(mrb, texture_class, "initialize", mrb_Texture_initialize, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, texture_class, "width", mrb_Texture_get_width, MRB_ARGS_NONE()); - mrb_define_method(mrb, texture_class, "width=", mrb_Texture_set_width, MRB_ARGS_REQ(1)); - //mrb_define_method(mrb, texture_class, "w", mrb_Texture_get_width, MRB_ARGS_NONE()); - //mrb_define_method(mrb, texture_class, "w=", mrb_Texture_set_width, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, texture_class, "height", mrb_Texture_get_height, MRB_ARGS_NONE()); - mrb_define_method(mrb, texture_class, "height=", mrb_Texture_set_height, MRB_ARGS_REQ(1)); - //mrb_define_method(mrb, texture_class, "h", mrb_Texture_get_height, MRB_ARGS_NONE()); - //mrb_define_method(mrb, texture_class, "h=", mrb_Texture_set_height, MRB_ARGS_REQ(1)); - mrb_define_method(mrb, texture_class, "id", mrb_Texture_get_id, MRB_ARGS_NONE()); - //mrb_define_method(mrb, texture_class, "mipmaps", mrb_Texture_get_mipmaps, MRB_ARGS_NONE()); - //mrb_define_method(mrb, texture_class, "format", mrb_Texture_get_format, MRB_ARGS_NONE()); - mrb_define_method(mrb, texture_class, "draw", mrb_Texture_draw_texture, MRB_ARGS_OPT(3)); - -} diff --git a/src/types.c b/src/types.c deleted file mode 100644 index 8889f8a..0000000 --- a/src/types.c +++ /dev/null @@ -1,62 +0,0 @@ -#include "mruby-raylib/types.h" -#include <raylib.h> - -const struct mrb_data_type Color_type = { - "Color", mrb_free -}; - -const struct mrb_data_type Rectangle_type = { - "Rectangle", mrb_free -}; - -const struct mrb_data_type Texture_type = { - "Texture", helper_texture_free -}; - -void -helper_texture_free(mrb_state* mrb, void*ptr) { - Texture *texture = (Texture*)ptr; - UnloadTexture(*texture); - mrb_free(mrb, ptr); -} - -const struct mrb_data_type Sound_type = { - "Sound", helper_sound_free -}; - -void -helper_sound_free(mrb_state* mrb, void*ptr) { - Sound *sound = (Sound*)ptr; - UnloadSound(*sound); - mrb_free(mrb, ptr); -} - -const struct mrb_data_type Music_type = { - "Music", helper_music_free -}; - -void -helper_music_free(mrb_state* mrb, void*ptr) { - Music *music = (Music*)ptr; - UnloadMusicStream(*music); - mrb_free(mrb, ptr); -} - -const struct mrb_data_type Vector2_type = { - "Vector2", mrb_free -}; - -const struct mrb_data_type NPatchInfo_type = { - "NPatchInfo", mrb_free -}; - -const struct mrb_data_type Font_type = { - "Font", helper_font_free -}; - -void -helper_font_free(mrb_state* mrb, void*ptr) { - Font *font = (Font*)ptr; - UnloadFont(*font); - mrb_free(mrb, ptr); -} |