Running Code

Here's an example of how to use a ChuckMainInstance / ChuckSubInstance, taken from the tutorials.

void OnTriggerEnter( Collider other )
{
	if( other.gameObject.CompareTag( "Pick Up" ) )
	{
		other.gameObject.SetActive( false );
		count = count + 1;
		SetCountText();

		GetComponent<ChuckSubInstance>().RunCode(@"
			SinOsc foo => dac;
			repeat( 5 )
			{
				Math.random2f( 300, 1000 ) => foo.freq;
				100::ms => now;
			}
		");
	}
}

Global Ints

Here's how it would look to set and get a global int. See also ChuckIntSyncer below for a simpler pattern that doesn't involve writing your own callback.

ChuckSubInstance myChuck;
Chuck.IntCallback myIntCallback;
long latestGottenInt;

void Start()
{
    myChuck = GetComponent<ChuckSubInstance>();
    myChuck.RunCode(@"
        global int myGlobalInt;
        // ...
    ");
    // create a callback to use with GetInt in Update()
    myIntCallback = myChuck.CreateGetIntCallback( MyGetIntCallbackFunction );
    
    // call SetInt
    myChuck.SetInt( "myGlobalInt", 5 );
}

void Update()
{
    // call the callback
    myChuck.GetInt( "myGlobalInt", myIntCallback );
    
    // do something with the gotten value
    Debug.Log( latestGottenInt );
}

void MyGetIntCallbackFunction( long newValue )
{
    latestGottenInt = newValue;
}

Global Floats

See Global Ints above for an example of how to get and set global variables. See also ChuckFloatSyncer below for a simpler pattern that doesn't involve writing your own callback.

Global Strings

See Global Ints above for an example of how to get and set global variables. See also ChuckStringSyncer below for a simpler pattern that doesn't involve writing your own callback.

Global Events

Here's an example of how to trigger and listen to global Events. See also ChuckEventListener below for a simpler pattern that doesn't involve communicating back from the audio thread to the Update() thread.

ChuckSubInstance myChuck;
Chuck.VoidCallback myEventCallback;

void Start()
{
    myChuck = GetComponent<ChuckSubInstance>();
    myChuck.RunCode( @"
        global Event startNotifying;
        global Event notifier;

        startNotifying => now;
        while( true )
        {
            notifier.broadcast();
            250::ms => now;
        }
    " );
    

    // call BroadcastEvent to trigger startNotifying
    myChuck.BroadcastEvent( "startNotifying" );

    // create a callback to use with StartListeningForChuckEvent
    myEventCallback = myChuck.CreateVoidCallback( MyEventReaction );

    // call my callback every time notifier broadcasts
    myChuck.StartListeningForChuckEvent( "notifier", myEventCallback );
}

// keep track of how many times the Event has
// broadcast on the audio thread
int numTimesEventHappenedOnAudioThread = 0;
void MyEventReaction()
{
    numTimesEventHappenedOnAudioThread++;
}

// use that information on the Update() thread
void Update()
{
    while( numTimesEventHappenedOnAudioThread > 0 )
    {
        numTimesEventHappenedOnAudioThread--;
        // Do something in Unity, e.g....
        transform.Rotate( ... );
    }
}

Global Int Arrays

See Global Ints above for an example of how to get and set global variables. Note that "associative array" is ChucK's version of a dictionary with string keys mapping to values (see ChucK documentation).

Global Float Arrays

See Global Ints above for an example of how to get and set global variables. Note that "associative array" is ChucK's version of a dictionary with string keys mapping to values (see ChucK documentation).

Unique Variables

You might want many copies running of a script that needs a global variable for communication between ChucK and Unity, but they all should not be referring to the same global variable. In this case, you should determine the name of each script's global variable at runtime.

ChuckSubInstance myChuck;
string myGlobalVariableName;

void Start()
{
    myChuck = GetComponent<ChuckSubInstance>();
    myGlobalVariableName = myChuck.GetUniqueVariableName();

    myChuck.RunCode( string.Format( @"
        global int {0};
        // ...
    ", myGlobalVariableName ) );
}

Specific to ChuckMainInstance

A ChuckMainInstance has one setting: the microphone used as input to its ChucK VM.

Specific to ChuckSubInstance

A ChuckSubInstance has two parameters for setting itself up. See the initial setup tutorial and the spatialization tutorial.

ChuckSubInstance myChuck;
ChuckEventListener myEventListener;

void Start()
{
    myChuck = GetComponent<ChuckSubInstance>();
    myChuck.RunCode( @"
        global Event startNotifying;
        global Event notifier;

        startNotifying => now;
        while( true )
        {
            notifier.broadcast();
            250::ms => now;
        }
    " );
    
    // call BroadcastEvent to trigger startNotifying
    myChuck.BroadcastEvent( "startNotifying" );

    // create an EventListener to call my callback
    myEventListener = gameObject.AddComponent<ChuckEventListener>();

    // call my callback every time notifier broadcasts
    myEventListener.ListenForEvent( myChuck, "notifier", MyEventReaction );
}

// this function will be called from the Update() thread
void MyEventReaction()
{
    // Do something in Unity
    transform.Rotate( ... );
}

ChuckSubInstance myChuck;
ChuckIntSyncer myIntSyncer;

void Start()
{
    myChuck = GetComponent<ChuckSubInstance>();
    myChuck.RunCode( @"
        global int myGlobalInt;
        // ...
    " );
    // create a callback to use with GetInt in Update()
    myIntSyncer = gameObject.AddComponent<ChuckIntSyncer>();

    // start syncing
    myIntSyncer.SyncInt( myChuck, "myGlobalInt" );
}

void Update()
{
    // get the most recently synced value
    Debug.Log( myIntSyncer.GetCurrentValue() );
}