How to get pointer to bool to pass to wrapped function?

[Morgayse]

Hi, I'm wrapping some ImGui functions, but ran into an issue.

My current, naive implementation where I define a new bool open which as I understand it gets its value populated from what is passed in, but when ImGui::ShowDemoWindow changes the value of open via the pointer &open, that clearly won't do anything to change the value of the variable in ruby.

  mrb_define_module_function(mrb, ImGui_module, "show_demo_window", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      bool open;
      mrb_get_args(mrb, "|b", &open);
      ImGui::ShowDemoWindow(&open);
      return mrb_nil_value();
    }, MRB_ARGS_OPT(1));

This is a snippet of how I'm invoking my wrapped function:

    if @show_demo_window
      ImGui.show_demo_window @show_demo_window
    end

What should happen is that the @show_demo_window passed in to ImGui.show_demo_window should be the "same one" passed into ImGui::ShowDemoWindow in C++, so that when the value is changed there, it's also changed up in ruby (and in this instance, will hide the demo window when its close button is clicked)

How might I accomplish what I'm looking to do here? Thank you for any help!

[dearblue]

As far as I can see, there are two things that are clearly wrong with the code you presented.

1. The type taken by the "b" specifier of the mrb_get_args() function is mrb_bool, which is incompatible with bool as defined in C/C++.
2. The "|" specifier and after in the mrb_get_args() function are optional arguments. If the omitted arguments are received by C, the C variables are not initialized. Please consider either of the following methods.
   • Initialize variables of C with their default values before calling mrb_get_args().
   • mrb_get_args() returns the number of arguments given, so branch with if or switch.

Here's an example fix:

--- #5618.cxx.orig
+++ #5618.cxx
@@ -1,6 +1,7 @@
   mrb_define_module_function(mrb, ImGui_module, "show_demo_window", [](mrb_state* mrb, mrb_value self) -> mrb_value {
-      bool open;
-      mrb_get_args(mrb, "|b", &open);
+      mrb_bool aopen = TRUE;
+      mrb_get_args(mrb, "|b", &aopen);
+      bool open = aopen ? true : false;
       ImGui::ShowDemoWindow(&open);
       return mrb_nil_value();
     }, MRB_ARGS_OPT(1));

[Morgayse]

Hi, thank you for the reply, and the tips about optional arguments. Some thoughts:

1. Doesn't value.h typedef mrb_bool as bool, so they are the same?
2. I did try that code out, but when I saw it, I believe it has the same issue mine has, which is that the address to the boolean passed into C++'s ImGui::ShowDemoWindow (&open in both our examples) doesn't correspond to anything in ruby-land (@show_demo_window in my example).

Since I really need a bool* not a bool, I thought perhaps I should use "o" for mrb_get_args, try to get some sort of raw mrb_value thing, and perhaps get a pointer to a value. And then I looked up how mrb_value and the mruby true/false values are made, and realized there isn't a raw boolean value we keep track of under mrb_value, it's done via the type. So then I thought, perhaps it's possible to monitor for changes and change the variable value from C++, something like this (I realize now I should touch this up a little to handle the optional args better, but this should still be a valid test case for the boolean thing)

      mrb_value p_open;
      mrb_get_args(mrb, "|o", &p_open);
      bool last_open { mrb_type(p_open) != MRB_TT_FALSE };
      bool open;
      std::cout << "Last open: " << last_open << ", pre open: " << open << ", mrb_type(p_open): " << mrb_type(p_open) << std::endl;;
      ImGui::ShowDemoWindow(&open);
      if (last_open && !open) { // need to flip ruby var
        std::cout << "******* ################################## FALSE ******************************" << std::endl;
        SET_FALSE_VALUE(p_open);
      } else if (!last_open && open) { // does this even happen?
        std::cout << "******* ################################## TRUE ******************************" << std::endl;
        SET_TRUE_VALUE(p_open);
      }
      std::cout << "Last open: " << last_open << ", post open: " << open << ", mrb_type(p_open): " << mrb_type(p_open) << std::endl;;
      return mrb_nil_value();
    }, MRB_ARGS_OPT(1));

The whole "last_open" thing is also super brittle and not generalizable, but again, more focusing on my own (lack of) understanding and getting it working, then I'll clean up the code and go from there.

Here's some output grabbed when it was running. I print the ruby value before and after the whole thing, and inside of that, print those C++ values. The whole point is I want to get the close button to close the window by changing the boolean to false, and here we see the ruby value always stay true, even though it appears the mruby p_open type goes to false (mrb_type(p_open) prints '0' instead of '1')

@show_demo_window pre value: true                                                                                                                                                                                 
Last open: 1, pre open: 0, mrb_type(p_open): 1                                                                                                                                                                    
******* ################################## FALSE ******************************                                                                                                                                   
Last open: 1, post open: 0, mrb_type(p_open): 0                                                                                                                                                                   
@show_demo_window post value: true                                                                                                                                                                                

As you can see, this doesn't work, and I have two thoughts:

1. the mrb_value p_open is a copy, so changing it does nothing
2. Something else I don't understand.

Out of an abundance of interest, I also made some bindings for ImGui::SliderFloat and ImGui::SliderInt. They don't work either, but both, differently. From looking at the SliderInt, it appears to be getting data from the ruby side correctly, but it won't change it, again making me think the mrb_values are copies...

Looking thru the mrb_get_args source, it looks like it copies the float/int values over into new memory. i.e.

    case 'f':
      {
        mrb_float *p;

        p = va_arg(ap, mrb_float*);
        if (pickarg) {
          *p = mrb_as_float(mrb, *pickarg);
        }
      }
      break;

I don't see any way to link these two layers up... except with maybe writing my own custom mrb_get_args to return original pointers to things instead of copies? Or maybe doing something with the "d" specifier and a custom data type?

I would appreciate any insight or thoughts. This is the first time I've tried creating mruby bindings that are this involved.

[Morgayse]

I originally was hoping to use the normal ruby literals in my code for this stuff, but I realized I could probably use a custom data type and ruby class. So I ended up defining a wrapping IntStar class to effectively manage the pointer and make it possible to extract easily when passing the IntStar instance around.

  RClass* const IntStar_class = mrb_define_class(mrb, "IntStar", mrb->object_class);
  MRB_SET_INSTANCE_TT(IntStar_class, MRB_TT_DATA);
  mrb_define_method(mrb, IntStar_class, "initialize", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_int n;
      mrb_get_args(mrb, "i", &n);
      int* data = (int*)DATA_PTR(self);
      if(data) { mrb_free(mrb, data); }
      mrb_data_init(self, nullptr, &IntStar_type);
      data = (int*)malloc(sizeof(int));
      *data = n;
      mrb_data_init(self, data, &IntStar_type);
      return self;
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, IntStar_class, "value", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      int* data = (int*)DATA_PTR(self);
      return mrb_fixnum_value(*data);
  }, MRB_ARGS_NONE());
  mrb_define_method(mrb, IntStar_class, "value=", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_int n;
      mrb_get_args(mrb, "i", &n);
      int* data = (int*)DATA_PTR(self);
      *data = n;
      return mrb_nil_value();
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, IntStar_class, "to_s", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      int* data = (int*)DATA_PTR(self);
      std::string str = std::to_string(*data);
      const char* c_str = str.c_str();
      mrb_value rstr = mrb_str_new_cstr(mrb, c_str);
      return rstr;
  }, MRB_ARGS_NONE());

And how to pull the pointer out when passed as an argument:

  mrb_define_module_function(mrb, ImGui_module, "slider_int", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      const char* label;
      int* v_ptr;
      mrb_int v_min;
      mrb_int v_max;
      mrb_get_args(mrb, "zdii", &label, &v_ptr, &IntStar_type, &v_min, &v_max);
      std::cout << "v_ptr: " << v_ptr << ", *v_ptr: " << *v_ptr << std::endl;
      ImGui::SliderInt(label, v_ptr, v_min, v_max);
      return mrb_nil_value();
    }, MRB_ARGS_REQ(4));

And how it's invoked in ruby:

    @my_int ||= IntStar.new 3
    ImGui.begin("My test window!", true, 0) do
      puts "@my_int pre: #{@my_int}"
      ImGui.slider_int "My Int", @my_int, 0, 10
      puts "@my_int post: #{@my_int}"
    end

And this works as desired. Here's some output when I changed the value using the input slider:

@my_int pre: 9
v_ptr: 0x56179b0cebf0, *v_ptr: 9
@my_int post: 10

And afaict the same thing should work for bool* and float* with some minor modifications. And then I'll probably want to get those classes behaving a bit more like the normal types, which ostensibly I could figure something out, so I don't have to call .value every I want to use the actual number/value in ruby. So I'm hoping I can clean up the syntax a bit, but this isn't too bad for my needs, although if anyone notices improvements that could be made here, I would love to learn!

I'm going to leave this open for a bit, but if what I have here is the best it's going to get, I'll mark it as an answer

[dearblue]

Sorry, my answer is wrong.
Also, I didn't recognize the intent of the question correctly.

1. Doesn't value.h typedef mrb_bool as bool, so they are the same?

Yes, it is. It is currently equivalent to C++ bool on C++.

2. I did try that code out, but when I saw it, I believe it has the same issue mine has, which is that the address to the boolean passed into C++'s ImGui::ShowDemoWindow (&open in both our examples) doesn't correspond to anything in ruby-land (@show_demo_window in my example).

If your intention is to change the caller's variables directly, you cannot do that in Ruby.
As mentioned in your reply, it needs to be wrapped in an object.

If want to keep things simple, it might be possible to use Array or Struct.

[Morgayse]

Thank you for the confirmation!

[Morgayse]

Here is what I'm currently using for int*, float*, and bool*.

  static const mrb_data_type IntPtr_type = {"IntPtr", mrb_free};
  static const mrb_data_type FloatPtr_type = {"FloatPtr", mrb_free};
  static const mrb_data_type BoolPtr_type = {"BoolPtr", mrb_free};
  // ...
  RClass* const IntPtr_class = mrb_define_class(mrb, "IntPtr", mrb->object_class);
  MRB_SET_INSTANCE_TT(IntPtr_class, MRB_TT_DATA);
  mrb_define_method(mrb, IntPtr_class, "initialize", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_int n;
      mrb_get_args(mrb, "i", &n);
      int* data = (int*)DATA_PTR(self);
      if(data) { mrb_free(mrb, data); }
      mrb_data_init(self, nullptr, &IntPtr_type);
      data = (int*)malloc(sizeof(int));
      *data = n;
      mrb_data_init(self, data, &IntPtr_type);
      return self;
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, IntPtr_class, "value", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      int* data = (int*)DATA_PTR(self);
      return mrb_fixnum_value(*data);
  }, MRB_ARGS_NONE());
  mrb_define_method(mrb, IntPtr_class, "value=", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_int n;
      mrb_get_args(mrb, "i", &n);
      int* data = (int*)DATA_PTR(self);
      *data = n;
      return mrb_nil_value();
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, IntPtr_class, "to_s", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      int* data = (int*)DATA_PTR(self);
      std::string str = std::to_string(*data);
      const char* c_str = str.c_str();
      mrb_value rstr = mrb_str_new_cstr(mrb, c_str);
      return rstr;
  }, MRB_ARGS_NONE());

  RClass* const FloatPtr_class = mrb_define_class(mrb, "FloatPtr", mrb->object_class);
  MRB_SET_INSTANCE_TT(FloatPtr_class, MRB_TT_DATA);
  mrb_define_method(mrb, FloatPtr_class, "initialize", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_float f;
      mrb_get_args(mrb, "f", &f);
      float* data = (float*)DATA_PTR(self);
      if(data) { mrb_free(mrb, data); }
      mrb_data_init(self, nullptr, &FloatPtr_type);
      data = (float*)malloc(sizeof(float));
      *data = f;
      mrb_data_init(self, data, &FloatPtr_type);
      return self;
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, FloatPtr_class, "value", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      float* data = (float*)DATA_PTR(self);
      return mrb_float_value(mrb, *data);
  }, MRB_ARGS_NONE());
  mrb_define_method(mrb, FloatPtr_class, "value=", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_float f;
      mrb_get_args(mrb, "f", &f);
      float* data = (float*)DATA_PTR(self);
      *data = f;
      return mrb_nil_value();
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, FloatPtr_class, "to_s", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      float* data = (float*)DATA_PTR(self);
      std::string str = std::to_string(*data);
      const char* c_str = str.c_str();
      mrb_value rstr = mrb_str_new_cstr(mrb, c_str);
      return rstr;
  }, MRB_ARGS_NONE());

  RClass* const BoolPtr_class = mrb_define_class(mrb, "BoolPtr", mrb->object_class);
  MRB_SET_INSTANCE_TT(BoolPtr_class, MRB_TT_DATA);
  mrb_define_method(mrb, BoolPtr_class, "initialize", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_bool b;
      mrb_get_args(mrb, "b", &b);
      bool* data = (bool*)DATA_PTR(self);
      if(data) { mrb_free(mrb, data); }
      mrb_data_init(self, nullptr, &BoolPtr_type);
      data = (bool*)malloc(sizeof(bool));
      *data = b;
      mrb_data_init(self, data, &BoolPtr_type);
      return self;
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, BoolPtr_class, "value", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      bool* data = (bool*)DATA_PTR(self);
      return mrb_bool_value(*data);
  }, MRB_ARGS_NONE());
  mrb_define_method(mrb, BoolPtr_class, "value=", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      mrb_bool b;
      mrb_get_args(mrb, "b", &b);
      bool* data = (bool*)DATA_PTR(self);
      *data = b;
      return mrb_nil_value();
  }, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, BoolPtr_class, "to_s", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      bool* data = (bool*)DATA_PTR(self);
      std::string str = std::to_string(*data);
      const char* c_str = str.c_str();
      mrb_value rstr = mrb_str_new_cstr(mrb, c_str);
      return rstr;
  }, MRB_ARGS_NONE());

Using as argument:

  // IntPtr example
  mrb_define_module_function(mrb, ImGui_module, "slider_int", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      const char* label;
      int* v_ptr;
      mrb_int v_min;
      mrb_int v_max;
      mrb_get_args(mrb, "zdii", &label, &v_ptr, &IntPtr_type, &v_min, &v_max);
      // std::cout << "v_ptr: " << v_ptr << ", *v_ptr: " << *v_ptr << std::endl;
      ImGui::SliderInt(label, v_ptr, v_min, v_max);
      return mrb_nil_value();
    }, MRB_ARGS_REQ(4));

  // FloatPtr example
  mrb_define_module_function(mrb, ImGui_module, "slider_float", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      const char* label;
      float* v_ptr;
      mrb_float v_min;
      mrb_float v_max;
      mrb_get_args(mrb, "zdff", &label, &v_ptr, &FloatPtr_type, &v_min, &v_max);
      // std::cout << "v_ptr: " << v_ptr << ", *v_ptr: " << *v_ptr << std::endl;
      ImGui::SliderFloat(label, v_ptr, v_min, v_max);
      return mrb_nil_value();
    }, MRB_ARGS_REQ(4));

  // BoolPtr example
  mrb_define_module_function(mrb, ImGui_module, "show_demo_window", [](mrb_state* mrb, mrb_value self) -> mrb_value {
      bool* p_open;
      switch(mrb_get_args(mrb, "|d", &p_open, &BoolPtr_type)) {
        case 0:
          ImGui::ShowDemoWindow();
          break;
        case 1:
          // std::cout << "p_open: " << p_open << ", *p_open: " << *p_open << std::endl;
          ImGui::ShowDemoWindow(p_open);
          break;
      }
      return mrb_nil_value();
    }, MRB_ARGS_OPT(1));

Using in mruby code

    @show_demo_window = BoolPtr.new true
    @my_float ||= FloatPtr.new 1.2
    @my_int ||= IntPtr.new 3
    # ...
    if @show_demo_window.value
      ImGui.show_demo_window @show_demo_window
    end
    # ...
    @test_window_open ||= BoolPtr.new true
    if @test_window_open.value
      ImGui.begin("My test window!", @test_window_open) do
        ImGui.slider_float "FOV", @my_float, 0, 10
        ImGui.slider_int "My Int", @my_int, 0, 10
      end
    end