I'm building a display wall demo application.
- N machines, each driving up to six displays
- Wired gigabit switch
- OpenTK application to draw the pretty pictures, running 1 copy on each node
Each node runs an identical copy of the demo executable. Each node also has some config data containing the resolution of the entire wall and the relative position of that node's displays within that space. When rendering, a scale/translation transform is applied after the projection matrix (effectively zooming in on the part of the view that the node is responsible for rendering).
The nodes have a "mode" switch set in a startup script that puts them in "send" or "receive" mode. All but one node is in "receive." (Switching a node to "send" causes all others to switch to "receive").
The demo app is a basic FPS-type fly through of some primitive geometry (grid, icosahedron, etc). On each update, the sender node broadcasts a UDP datagram containing some state information (camera translation/rotation, transforms for moving objects).
Listeners asynchronously receive these datagrams, deserialize the state and update their local copies.
The net effect is that I run the app on my laptop and fly around, and the wall nicely follows along. This all works pretty well.
However, I'm concerned that as the system scales (from 10 displays to, say, 500), that network latency will be an issue. I've also thought that, rather than spamming state across the network this way, it would be nice to stuff it into a database and have each node just pull from there, but I doubt any off the shelf databases are going to be up to a 60FPS * 500 nodes cycle.
Suggestions? What's the best way to share state between a lot of nodes really, really fast?