Cinemachine object is different across machines

Hi,

I'm working on a project with two colleagues and we are using Cinemachine to keep the character in view.

Cinemachine tries to modify the scene on each of our machines even when nothing changes.
It changes the with

m_SensorSize: {x: 1.8085107, y: 1}

to various different ones like

m_SensorSize: {x: 1.7777778, y: 1}

or

{x: 1.7789757, y: 1}

. It is a property of the virtual camera object and

m_Lens

. We are using text format serialization, because of version control (git). But I can see this will be an issue on any kind of version control.
Looks like it depends on the machine resolution or something.

How do people actually work on this? It seems impossible. Every change between our machines is basically a conflict in this file and line.

 

Hey,

sure. It is public on https://github.com/timewarpinc/submarine

For example the last commit https://github.com/timewarpinc/submarine/commit/df926d1e2b2ce424aaeae43365c15c9a63235482
changes m_Lens after my colleague saved the scene on other machine. These are values for MacBook 16". It does not matter the actual display scaling.

Just enable/disable some object in the scene a save it to see the changes pop up.


Cheers!

 

Hi,

I tried. Disabling CinemachineBrain in the Main Camera and then forcing saving the scene by disable/enable the main camera produces no changes to the m_SensorSize. Just enabling the Brain will produce m_SensorSize change.
Pushed it as https://github.com/timewarpinc/submarine/tree/cinemachine-brain-reproduce

But I have the same issue again in a different project using URP.
And we are not ignoring any .meta files, so it is not that.
It changes other fields like `m_LocalRotation` and `m_LocalPosition` by tiny fractions. Looks like rounding errors between platforms.

 

Yes, it is set to Free Aspect, because that is the default. And everyone uses different screen, so likely different aspect ratio.

 

I am experiencing this and it is driving me nuts!
I have a team of 7 working on the project and we constantly have these changes cluttering our version control.
I am set to 16:9 but I cannot expect all of my teammates to also use this.
Is is possible to prevent serializing these properties?

 

I just did a quick solo test on my machine. The aspect ratio definitely seems to be the culprit.

I opened one of the scenes where we often see this issue and made a change (change layer assignment on a GameObject) and saved it with my aspect ratio set to 16:10, which came with some SensorSize and position changes on the virtual camera. I committed that change.

Then I set the aspect ratio to 16:9 and changed the layer assignment again. I see SensorSize and position changes in Git. Notably, if I just open the scene and change the aspect ratio and save this doesn't happen, likely because that doesn't mark the scene as dirty on its own.
If I then (without committing that last change) set the GameObject layer back to what it was on the previous commit and save again, that change goes away but the SensorSize and position changes are still present.

Here's the part you've been waiting for....
With that change staged waiting to be committed.... if I then change my aspect ratio back to 16:10 as it was in my last commit, and make another GameObject change to trigger the save, Git now shows the only change is the GameObject layer (or none if you changed it back to what's in the repo).

Some more details:
The changes are appearing on a virtual camera. I've got a few in the scene so it took me a bit to narrow down which one this is occurring on; It's the one that renders the game view when I'm not in play mode.
If I play the game and cycle through a few cameras, then presumably any camera that was active at some point changes the SensorSize and position when I save the scene. But without hitting Play, the only one that seems to change is the one showing in the Game window.

I've asked my team to try it out, but I think this test gave us enough data.

 

In a nearly empty scene I reproduced the issue.

1. Create scene and add a Cinemachine camera and an empty GameObject.
2. Set Aspect ratio to 16:9 in Game window
3. Commit to Git.
4. Change aspect ratio to 16:10, make any edit to the GameObject (like position), and save the scene.
5. Observe in Git that the only pending change is the GameObject.
6. Add a Cinemachine Virtual Camera. Repeat steps 2 through 4.
7. Observe in Git that there are now pending changes to the m_SensorSize on the virtual camera.

So this seems to be occurring only on virtual cameras, and only when you've changed the aspect ratio (or resized the free aspect) from what's in the Git repository, and made any other edits to the scene before saving.

 

In my main scene, I also see a change to m_LocalPosition.x - If I dig into the text further up this looks like it's coming from one of my virtual cameras' Cinemachine Volume Settings custom focus tracking target. This change shows up whenever I see the SensorSize changes.

 

Was there any progress on this? I'm seeing it as well and its pretty annoying when working in a team. Is there a bug report to watch?

 

Thank you so much!
I confirmed the fix by following the same test methodology in a project with Cinemachine 2.8.9 and saw no unexpected git changes. This will save my team so much time in resolving merge conflicts.