Some people said that my problems were not specific enough. I made a document to introduce our project, the methods I adopted and the problems I am facing. My boss is willing to pay if your suggestion works. At the same time, I will also attach the content of the original problem. Don’t forget to download my document to obtain specific problem information. Thank anyone for their selfless help.
============last question
Recently, I am working on a real-time rendering based on unity through distributed rendering. There are many moving objects related to logic in this scene. Now I use the way of RPC call to synchronize the master and slave worlds. However, due to the lag of message transmission, the slave world cannot be completely synchronized, resulting in the dislocation of the picture when the segmented scenes are spliced together.Anybody knows something about parallel rendering using multiple computers, and the rendering is real-time rendering?[186794-gaojujian-problem.pdf|186794]
judging from the information you have given i’d suggest the following (assuming that i understood your problem which i am honestly not completly sure of)
To put your problem in my own words: while you manage to render the scene on 4 different machines, the state of the scene is not always in sync for the frames that you render. So when you merge them into one frame in the end the 4 image parts do not match up.
How to solve this?
In my head i can only think of one valid solution here: you need proper state tracking and synchronization. Instead of sending an empty rpc to trigger certain events and then hoping that they match up in the end you should create some kind of container to hold all necessary data that defines in what state your complete machinery is. So somewhat in that direction:
[System.Serializable]
public class sceneStateSnapshot
{
public long snapshotID; //unique snapshotID to make sure you always know what state this refers to
public Vector3 cameraPosition;
public Quaternion cameraRotation;
public machineStateSnapshot[] machineStates;
}
[System.Serializable]
public class machineStateSnapshot{
public int ID;//unique machineID;
public machineElementStatus[] machineElementStates;
}
[System.Serializable]
public class machineElementStatus {
public int ID; //unique elementID;
public Vector3 posOfSomeElement;
public Quaternion rotOfSomeElement;
public float someOtherValueThatYouCouldSync;
}
This for example could be how you structure a data container that can be created on the Master to define what kind of state your current scene is in.
Then you can set a camera position and rotation and send this to a client. When the client recieves this
you can unpack the data, set all transform rotations/positions accordingly as well as the camera position, render the scene and send the resulting image back to the master. When sending the result you attach the snapshotID to make sure that the master knows which images are to be stiched together.
Potential additional benefits from this: Your clients do not have to run any Update logic. You could theoretically disable all this as you only have to react on the event when you recieve a new “renderSnapshot” command. This way you can potentially save a few ms. Additionaly you can be sure that all clients always mirror the exact state that the master decided. All decisions are thus done by the master and the clients are truly just render instances.
Potential issues: Since i don’t know how many states we are talking about the stateSnapshot might be really large. You might need some compression here. Also i am not sure if Unitys builtin networking is made for this kind of stuff. I can recommend to check out DarkRift2 as this should from my experience be the easiest to use fast lowlevel Networking solution out there which should work out of the box in your LAN.
Let me know what you think or if you see any problems with this suggestion.
Parallel rendering (or distributed rendering) is the application of parallel programming to the computational domain of computer graphics. … Rendering is an embarrassingly parallel workload in multiple domains (e.g., pixels, objects, frames) and thus has been the subject of much research.