Making Unity call a function on the React side? about core HOT 6 CLOSED

Yep, ScriptObject will also work, but it is specific to one engine (either Jint or ClearScript). Callback should be able to handle all existing (and future) Javascript engines ReactUnity supports. So that you can switch the JS engine without needing to change any code.

from core.

Are you trying to pass a Javascript function as argument to C# side? If so ReactUnity has a helper class to do that, which is used internally to handle event callbacks, but is also intended for external usage. You can use it like:

// unity.cs

int counter = 0;

public void DoThing(ReactUnity.Helpers.Callback callback)
{
  counter++;
  callback.Call(counter);
}

//react.tsx

// You should probably memo this for better performance
const callback = Interop.ReactUnity.Helpers.Callback.From((counter: number) => {
    console.log(counter);
});

...
onClick={() =>
  globals.unity.DoThing(callback)
}

Note that you should also memo onClick function but it is up to you.

from core.

Alternatively, you can convert to Callback in C# side:

// unity.cs

int counter = 0;

public void DoThing(object cb)
{
  var callback = ReactUnity.Helpers.Callback.From(cb);
  counter++;
  callback.Call(counter);
}

// react.tsx

onClick={() =>
  globals.unity.DoThing((counter: number) => {
    console.log(counter);
  })
}

from core.

Yes, exactly what I needed. I actually just came back here to say I figured out that using ScriptObject worked, but that helper method seems better. Thanks!

Just for reference, this is what I was doing:

public void DoThing(ScriptObject callback)
{
  counter++;
  callback.Invoke(false, counter);
}

from core.

Thanks for clarifying. I mention some React tips from time to time because I guess most people using Unity won't know how to use React well. It is all ok if you know what you are doing.

from core.

Ah you're too fast. I deleted my remark about memo because I realized you suggested it due to Helpers.Callback.From(), I'm guessing that's the part that can be slow. In which case the suggestion makes sense. Thanks again!

from core.