Goals

As the project transitioned to an online phase, I decided to re-check all the systems and features to make sure they’re running properly for the user testing. There are two things that I have to check for the testing to run smoothly:

• Ensuring the WebSocket parser works, and identify any upcoming errors
• Custom controller detects the current space state, and translate it to the correct visual

Achieving this two tasks requires me to adjust many things within the backbone.

Controller Reconfigured

During the physical prototyping, the visual state was controlled using manual keyboard presses. But this time, the transition from Manual to Automated required more than just changing the trigger source. I had to move to a verifying script. The new logic validates the data (activeLayers), checks for the existence of assets, and handles the A/B state flip internally, ensuring a seamless experience even with jittery sensor data.

Fundamentally, the difference is as follows:

• Old Code was built for manual keyboard input. It relied on a “Fan CHOP” where every button press was a unique event. It didn’t care if the visual path actually existed or if the number was a clean integer.

• New Code is built for sensor automation. It handles “dirty” data by rounding values, verifies paths exist before switching to avoid crashes, and includes a debugging layer to track state changes in the Textport.

Major Improvements

Error Prevention: » In the Old Code, if the sensor outputted a 4 but I only had visuals v_0 through v_3, the script would throw a Python error and stop working. The New Code handles this:

1
if op(f'/Visuals/v_{target_v}') is None:
2
    debug(f"Warning: Visual v_{target_v} not found...")
3
    return

Automated State Swapping » The Old Code required me to press a key to flip the state. The New Code detects a value change from the sensor and flips the “A/B” state automatically, making it hands-free:

1
new_state = 1 if curr_param.par.value0 == 0 else 0
2
curr_param.par.value0 = new_state

Remapping Jitters

Apart from revamping the controller architecture, I also tweaked and adjusted the jitter as the main parameter to control the Voronoi base visual “waviness.” This is achieved by inputting the data from the WebSocket parser into each visual state apart from Calm State because it has fixed parameter.

Through in-house testing with Yaakulya before user testing, I figured the jitter data either jumped closer to 1 when very chaotic, or close to 0 when calm. Thus, as the main parameter that controls how much cells are visible in the base visual, I decided to have it mapped between 0-0.75 and > 0.75:

In Action

We conducted a user testing entirely online, using Zoom screen sharing to broadcast the TouchDesigner output from my local machine to the participants. This setup aimed to replicate the Collective Presence described in the original design where the environment responds to the group’s state, but through a distributed network rather than a shared physical room. The participants interacted with the system by providing inputs that were sent as JSON packets via the WebSocket server into my TouchDesigner Controller module.

After Thoughts

Moving from a controlled studio to a remote WebSocket environment introduced three “invisible” enemies that nearly broke the immersion of Senspace:

• The Latency Trap: Request Timeouts (RTO) in the WebSocket stream created a lag between human action and visual reaction. In a restorative space, even a split-second delay shatters the user’s sense of agency.

• The Jitter Problem: Raw data is messy. Without aggressive filtering, sensor noise translated into “sickly” visual jitters. I learned that for art to feel “natural,” the system must prioritize visual stability over raw data responsiveness.

• Asymmetric Performance: What looked smooth on my host machine lagged for the participants. Handshaking over the internet proved that bandwidth can be the ultimate gatekeeper of artistic fluency.

Looking back at our journey from the initial Cozy Corner pitch to the final state-machine visuals, Senspace taught me that a capstone project isn’t a linear path but a constant discourse between code and human response.

The Chasm Between Good and Great

It is easy to make a visual that reacts to a sensor. It is incredibly difficult to make that reaction feel like a natural extension of human emotion. I’ve gained a profound respect for the masters of this craft; I now realize that their “simplicity” isn’t a lack of complexity—it is the result of mastering it.

Designing for “Less”

This project reshaped my philosophy as a creator. I no longer see technology as a tool for “doing more,” but as a medium for “being.” In a world of constant directed attention, the most powerful thing we can design is a space that allows the mind to finally think of less.