Unique Noise Seed OSC.

2024-05-16 16:19 UTC gpt-4o Open in ChatGPT ↗

To achieve this in TouchDesigner, you can use a combination of the OSC DAT, a Time COMP, and a Noise TOP to ensure that your noise seed value changes each time an OSC message is received, even if the OSC value remains the same. Here’s a step-by-step guide on how to set this up:

OSC DAT Setup:
- Add an OSC In DAT to receive OSC messages.
Fetch OSC Values:
- Add a Select DAT to extract the specific OSC value you want to use.
Create a Changing Seed:
- Use a Time COMP to get the current frame number or milliseconds, which will be unique at each moment.
- Add a Logic CHOP to detect changes in the OSC value.
- Use a Math CHOP to combine the OSC value with the current time to create a unique seed each time an OSC message is received.
Drive Noise Seed:
- Connect the output of the Math CHOP to the seed parameter of the Noise TOP.

Here are the detailed steps:

OSC In DAT:
- Add an OSC In DAT and configure it to receive messages from your OSC source.
Select DAT:
- Add a Select DAT and connect it to the OSC In DAT.
- Select the specific row/column that contains your OSC value.
Time COMP:
- Add a Time COMP to your network.
- Add a CHOP to DAT to convert the time to a CHOP.
- Configure the CHOP to DAT to output the frame or seconds value.
Logic CHOP:
- Add a Logic CHOP and connect it to the output of your Select DAT.
- Set the Logic CHOP to ‘on when value changes’.
Math CHOP:
- Add a Math CHOP and connect the output of the Logic CHOP and the CHOP to DAT (from the Time COMP) to its inputs.
- Use the Add operation in the Math CHOP to combine the OSC value with the current frame number or time.
Noise TOP:
- Add a Noise TOP.
- Connect the output of the Math CHOP to the seed parameter of the Noise TOP.

Example Network:

OSC In DAT:
- OSC In DAT receives OSC messages.
Select DAT:
- Select DAT extracts the relevant OSC value.
Time COMP:
- Time COMP gets the current frame or time.
Logic CHOP:
- Logic CHOP detects changes in the OSC value.
Math CHOP:
- Math CHOP combines the OSC value with the current time/frame to create a unique seed.
Noise TOP:
- Noise TOP uses the combined value as its seed.

This setup ensures that even if the OSC value remains the same, the seed for the Noise TOP will be different each time an OSC message is received, resulting in different noise patterns.

Certainly! You can adjust your current setup to incorporate the time or frame information to ensure the noise seed value changes every time a new OSC message is received, even if the OSC value remains the same.

Here’s an updated expression you can use for the seed value of your Noise TOP:

(op('oscin3')['angel'] + int(op('timer1').frame)) % 1000000

Let’s break this down:

OSC Value: op('oscin3')['angel'] fetches the current value of the ‘angel’ channel from the OSC In CHOP.
Current Frame: int(op('timer1').frame) fetches the current frame number from a Timer CHOP named timer1.
Combine Values: Adding the OSC value to the current frame number ensures that the seed changes each time a new frame is processed.
Modulo Operation: Using % 1000000 limits the range of the seed to a manageable number, avoiding excessively large values.

Detailed Steps:

Timer CHOP:
- Add a Timer CHOP to your network. This will provide the current frame number.
- Make sure the Timer CHOP is running continuously. You can do this by setting it to loop indefinitely.
Noise TOP Seed Expression:
- Update the seed parameter of your Noise TOP with the following expression:
```
(op('oscin3')['angel'] + int(op('timer1').frame)) % 1000000
```
Ensure the Timer CHOP is Running:
- Go to the Timer CHOP parameters and set it to loop continuously by enabling the Loop parameter.

Final Touch:

If you prefer to use milliseconds instead of frames, you can use the following expression:

(op('oscin3')['angel'] + int(op('timer1').time.seconds * 1000)) % 1000000

Here’s what it does:

Current Time in Milliseconds: int(op('timer1').time.seconds * 1000) converts the current time to milliseconds.
Combine and Modulo: This is combined with the OSC value and limited to a range using the modulo operation.

This setup ensures that your Noise TOP seed value changes with every new OSC message due to the incorporation of the current frame or time, providing a unique seed each time even if the OSC value remains unchanged.

Apologies for the confusion. The Timer CHOP does not have a frame attribute directly. Instead, you can use the frame or absFrame from the current global time. Here’s how you can modify the expression to use the global frame number:

Updated Expression Using Global Frame:

(op('oscin3')['angel'].eval() + int(op('timer1')['frame'])) % 1000000

Alternatively, if you want to use the absolute frame directly, you can do this:

(op('oscin3')['angel'].eval() + int(absTime.frame)) % 1000000

Let’s break this down:

OSC Value: op('oscin3')['angel'].eval() fetches the current value of the ‘angel’ channel from the OSC In CHOP.
Current Global Frame: int(absTime.frame) fetches the current absolute frame number from the global time.
Combine Values: Adding the OSC value to the current frame number ensures that the seed changes each time a new frame is processed.
Modulo Operation: Using % 1000000 limits the range of the seed to a manageable number, avoiding excessively large values.

Step-by-Step Instructions:

Timer CHOP (if you need it for something else):
- If you already have a Timer CHOP for other purposes, you can still use it. But for simplicity, using the global absTime is more straightforward in this case.
Noise TOP Seed Expression:
- Update the seed parameter of your Noise TOP with the following expression:
```
(op('oscin3')['angel'].eval() + int(absTime.frame)) % 1000000
```

This setup ensures that your Noise TOP seed value changes with every new OSC message due to the incorporation of the current global frame number, providing a unique seed each time even if the OSC value remains unchanged.

To ensure that the seed value only changes when a new OSC command is received, you can use a combination of a CHOP Execute DAT to detect changes in the OSC value and then update the seed accordingly.

Here’s a step-by-step guide:

OSC In CHOP:
- Ensure your OSC In CHOP is receiving values and has a channel named ‘angel’.
CHOP Execute DAT:
- Add a CHOP Execute DAT and connect it to the OSC In CHOP.
- Configure the CHOP Execute DAT to run a script whenever the value of the ‘angel’ channel changes.
Script to Update Seed:
- In the CHOP Execute DAT, write a script to update the seed value of the Noise TOP using a combination of the OSC value and the current frame.

Detailed Steps:

Add CHOP Execute DAT:
- Add a CHOP Execute DAT and connect it to your OSC In CHOP.
- Set the CHOP Execute DAT to monitor the ‘angel’ channel.
Configure CHOP Execute DAT:
- Set the parameters as follows:
  - Off to On: Enable this.
  - Value Change: Enable this.
  - Channel Name: Set to ‘angel’ (or leave it blank to respond to any channel change).
Write the Script:
- In the CHOP Execute DAT callback script, update the seed parameter of the Noise TOP.

Here’s an example script for the CHOP Execute DAT:

def onValueChange(channel, sampleIndex, val, prev):
    # Fetch the current OSC value
    osc_value = op('oscin3')['angel'].eval()

    # Fetch the current frame number
    current_frame = int(absTime.frame)

    # Calculate the new seed value
    new_seed = (osc_value + current_frame) % 1000000

    # Set the seed value of the Noise TOP
    op('noise1').par.seed = new_seed

    return

Final Setup:

OSC In CHOP:
- Ensure it’s correctly receiving the OSC values.
CHOP Execute DAT:
- Add and configure it to detect changes in the ‘angel’ channel.
Update the Seed:
- Use the script in the CHOP Execute DAT to update the Noise TOP seed value only when a new OSC command is received.

Putting It All Together:

Add an OSC In CHOP:
- Ensure your OSC In CHOP is named oscin3.
Add a Noise TOP:
- Ensure your Noise TOP is named noise1.
Add a CHOP Execute DAT:
- Connect it to oscin3.
- Use the provided script to update the Noise TOP’s seed parameter.

This setup ensures that the seed value for the Noise TOP only changes when a new OSC message is received, even if the OSC value is the same.

To generate a truly random seed each time a new OSC command is received, you can use Python’s random module within the CHOP Execute DAT script. This ensures that a different random seed is produced every time the script runs, regardless of the OSC value.

Here’s how you can do it:

Ensure OSC In CHOP:
- Your OSC In CHOP should be named oscin3 and receiving values.
Add CHOP Execute DAT:
- Connect a CHOP Execute DAT to the OSC In CHOP.
Write the Script Using Python’s random Module:
- Use the random module to generate a random seed value each time a new OSC command is received.

Script for CHOP Execute DAT:

Import the random Module:
- Ensure the script imports the random module.
Generate a Random Seed:
- Use random.randint to generate a random integer as the seed.

Example Script:

import random

def onValueChange(channel, sampleIndex, val, prev):
    # Generate a random seed
    new_seed = random.randint(0, 1000000)

    # Set the seed value of the Noise TOP
    op('noise1').par.seed = new_seed

    return

Steps to Implement:

Configure CHOP Execute DAT:
- Add the CHOP Execute DAT and connect it to your OSC In CHOP.
- Set it to monitor the ‘angel’ channel.
- Enable Off to On and Value Change.
Script Implementation:
- Open the CHOP Execute DAT and enter the above script.
- Ensure noise1 is the name of your Noise TOP.

Putting It All Together:

OSC In CHOP:
- Ensure it’s named oscin3 and is correctly receiving OSC values.
Add Noise TOP:
- Ensure it’s named noise1.
Add CHOP Execute DAT:
- Connect it to oscin3.
- Use the provided script to generate a random seed each time a new OSC command is received.

This approach will ensure that a new random seed is used for the Noise TOP each time an OSC message is received, regardless of the value of the OSC message.