chore: Tighten up the APIs of NetworkAnimator and NetworkTransform to leave public only what's needed (#1897)

jeffreyrainy · 0xFA11 · web-flow · commit 381dc4f73f9c · 2022-04-25T20:42:59.000Z
* chore: Thighten up the APIs of NetworkAnimator and NetworkTransform to leave public only what's needed

* Update com.unity.netcode.gameobjects/Components/NetworkAnimator.cs

* minor syntax fix

Co-authored-by: Fatih Mar &lt;mfatihmar@gmail.com&gt;
diff --git a/com.unity.netcode.gameobjects/Components/NetworkAnimator.cs b/com.unity.netcode.gameobjects/Components/NetworkAnimator.cs
@@ -15,11 +15,11 @@ public class NetworkAnimator : NetworkBehaviour
         internal struct AnimationMessage : INetworkSerializable
         {
             // state hash per layer.  if non-zero, then Play() this animation, skipping transitions
-            public int StateHash;
-            public float NormalizedTime;
-            public int Layer;
-            public float Weight;
-            public byte[] Parameters;
+            internal int StateHash;
+            internal float NormalizedTime;
+            internal int Layer;
+            internal float Weight;
+            internal byte[] Parameters;
 
             public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
@@ -33,8 +33,8 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
 
         internal struct AnimationTriggerMessage : INetworkSerializable
         {
-            public int Hash;
-            public bool Reset;
+            internal int Hash;
+            internal bool Reset;
 
             public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
@@ -57,29 +57,29 @@ public Animator Animator
         private bool m_SendMessagesAllowed = false;
 
         // Animators only support up to 32 params
-        public static int K_MaxAnimationParams = 32;
+        private const int k_MaxAnimationParams = 32;
 
         private int[] m_TransitionHash;
         private int[] m_AnimationHash;
         private float[] m_LayerWeights;
 
         private unsafe struct AnimatorParamCache
         {
-            public int Hash;
-            public int Type;
-            public fixed byte Value[4]; // this is a max size of 4 bytes
+            internal int Hash;
+            internal int Type;
+            internal fixed byte Value[4]; // this is a max size of 4 bytes
         }
 
         // 128 bytes per Animator
-        private FastBufferWriter m_ParameterWriter = new FastBufferWriter(K_MaxAnimationParams * sizeof(float), Allocator.Persistent);
+        private FastBufferWriter m_ParameterWriter = new FastBufferWriter(k_MaxAnimationParams * sizeof(float), Allocator.Persistent);
         private NativeArray<AnimatorParamCache> m_CachedAnimatorParameters;
 
         // We cache these values because UnsafeUtility.EnumToInt uses direct IL that allows a non-boxing conversion
         private struct AnimationParamEnumWrapper
         {
-            public static readonly int AnimatorControllerParameterInt;
-            public static readonly int AnimatorControllerParameterFloat;
-            public static readonly int AnimatorControllerParameterBool;
+            internal static readonly int AnimatorControllerParameterInt;
+            internal static readonly int AnimatorControllerParameterFloat;
+            internal static readonly int AnimatorControllerParameterBool;
 
             static AnimationParamEnumWrapper()
             {
diff --git a/com.unity.netcode.gameobjects/Components/NetworkTransform.cs b/com.unity.netcode.gameobjects/Components/NetworkTransform.cs
@@ -39,7 +39,7 @@ internal struct NetworkTransformState : INetworkSerializable
             // 11-15: <unused>
             private ushort m_Bitset;
 
-            public bool InLocalSpace
+            internal bool InLocalSpace
             {
                 get => (m_Bitset & (1 << k_InLocalSpaceBit)) != 0;
                 set
@@ -50,7 +50,7 @@ public bool InLocalSpace
             }
 
             // Position
-            public bool HasPositionX
+            internal bool HasPositionX
             {
                 get => (m_Bitset & (1 << k_PositionXBit)) != 0;
                 set
@@ -60,7 +60,7 @@ public bool HasPositionX
                 }
             }
 
-            public bool HasPositionY
+            internal bool HasPositionY
             {
                 get => (m_Bitset & (1 << k_PositionYBit)) != 0;
                 set
@@ -70,7 +70,7 @@ public bool HasPositionY
                 }
             }
 
-            public bool HasPositionZ
+            internal bool HasPositionZ
             {
                 get => (m_Bitset & (1 << k_PositionZBit)) != 0;
                 set
@@ -81,7 +81,7 @@ public bool HasPositionZ
             }
 
             // RotAngles
-            public bool HasRotAngleX
+            internal bool HasRotAngleX
             {
                 get => (m_Bitset & (1 << k_RotAngleXBit)) != 0;
                 set
@@ -91,7 +91,7 @@ public bool HasRotAngleX
                 }
             }
 
-            public bool HasRotAngleY
+            internal bool HasRotAngleY
             {
                 get => (m_Bitset & (1 << k_RotAngleYBit)) != 0;
                 set
@@ -101,7 +101,7 @@ public bool HasRotAngleY
                 }
             }
 
-            public bool HasRotAngleZ
+            internal bool HasRotAngleZ
             {
                 get => (m_Bitset & (1 << k_RotAngleZBit)) != 0;
                 set
@@ -112,7 +112,7 @@ public bool HasRotAngleZ
             }
 
             // Scale
-            public bool HasScaleX
+            internal bool HasScaleX
             {
                 get => (m_Bitset & (1 << k_ScaleXBit)) != 0;
                 set
@@ -122,7 +122,7 @@ public bool HasScaleX
                 }
             }
 
-            public bool HasScaleY
+            internal bool HasScaleY
             {
                 get => (m_Bitset & (1 << k_ScaleYBit)) != 0;
                 set
@@ -132,7 +132,7 @@ public bool HasScaleY
                 }
             }
 
-            public bool HasScaleZ
+            internal bool HasScaleZ
             {
                 get => (m_Bitset & (1 << k_ScaleZBit)) != 0;
                 set
@@ -142,7 +142,7 @@ public bool HasScaleZ
                 }
             }
 
-            public bool IsTeleportingNextFrame
+            internal bool IsTeleportingNextFrame
             {
                 get => (m_Bitset & (1 << k_TeleportingBit)) != 0;
                 set
@@ -152,12 +152,12 @@ public bool IsTeleportingNextFrame
                 }
             }
 
-            public float PositionX, PositionY, PositionZ;
-            public float RotAngleX, RotAngleY, RotAngleZ;
-            public float ScaleX, ScaleY, ScaleZ;
-            public double SentTime;
+            internal float PositionX, PositionY, PositionZ;
+            internal float RotAngleX, RotAngleY, RotAngleZ;
+            internal float ScaleX, ScaleY, ScaleZ;
+            internal double SentTime;
 
-            public Vector3 Position
+            internal Vector3 Position
             {
                 get { return new Vector3(PositionX, PositionY, PositionZ); }
                 set
@@ -168,7 +168,7 @@ public Vector3 Position
                 }
             }
 
-            public Vector3 Rotation
+            internal Vector3 Rotation
             {
                 get { return new Vector3(RotAngleX, RotAngleY, RotAngleZ); }
                 set
@@ -179,7 +179,7 @@ public Vector3 Rotation
                 }
             }
 
-            public Vector3 Scale
+            internal Vector3 Scale
             {
                 get { return new Vector3(ScaleX, ScaleY, ScaleZ); }
                 set
@@ -795,8 +795,6 @@ private void Initialize()
             }
         }
 
-        #region state set
-
         /// <summary>
         /// Directly sets a state on the authoritative transform.
         /// This will override any changes made previously to the transform
@@ -856,7 +854,6 @@ private void SetStateServerRpc(Vector3 pos, Quaternion rot, Vector3 scale, bool
             m_Transform.localScale = scale;
             m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = shouldTeleport;
         }
-        #endregion
 
         // todo this is currently in update, to be able to catch any transform changes. A FixedUpdate mode could be added to be less intense, but it'd be
         // conditional to users only making transform update changes in FixedUpdate.

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ internal struct NetworkTransformState : INetworkSerializable`
`39`	`39`	`// 11-15: <unused>`
`40`	`40`	`private ushort m_Bitset;`
`41`	`41`
`42`		`- public bool InLocalSpace`
	`42`	`+ internal bool InLocalSpace`
`43`	`43`	`{`
`44`	`44`	`get => (m_Bitset & (1 << k_InLocalSpaceBit)) != 0;`
`45`	`45`	`set`
`@@ -50,7 +50,7 @@ public bool InLocalSpace`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`// Position`
`53`		`- public bool HasPositionX`
	`53`	`+ internal bool HasPositionX`
`54`	`54`	`{`
`55`	`55`	`get => (m_Bitset & (1 << k_PositionXBit)) != 0;`
`56`	`56`	`set`
`@@ -60,7 +60,7 @@ public bool HasPositionX`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`		`- public bool HasPositionY`
	`63`	`+ internal bool HasPositionY`
`64`	`64`	`{`
`65`	`65`	`get => (m_Bitset & (1 << k_PositionYBit)) != 0;`
`66`	`66`	`set`
`@@ -70,7 +70,7 @@ public bool HasPositionY`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`73`		`- public bool HasPositionZ`
	`73`	`+ internal bool HasPositionZ`
`74`	`74`	`{`
`75`	`75`	`get => (m_Bitset & (1 << k_PositionZBit)) != 0;`
`76`	`76`	`set`
`@@ -81,7 +81,7 @@ public bool HasPositionZ`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`// RotAngles`
`84`		`- public bool HasRotAngleX`
	`84`	`+ internal bool HasRotAngleX`
`85`	`85`	`{`
`86`	`86`	`get => (m_Bitset & (1 << k_RotAngleXBit)) != 0;`
`87`	`87`	`set`
`@@ -91,7 +91,7 @@ public bool HasRotAngleX`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`- public bool HasRotAngleY`
	`94`	`+ internal bool HasRotAngleY`
`95`	`95`	`{`
`96`	`96`	`get => (m_Bitset & (1 << k_RotAngleYBit)) != 0;`
`97`	`97`	`set`
`@@ -101,7 +101,7 @@ public bool HasRotAngleY`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`- public bool HasRotAngleZ`
	`104`	`+ internal bool HasRotAngleZ`
`105`	`105`	`{`
`106`	`106`	`get => (m_Bitset & (1 << k_RotAngleZBit)) != 0;`
`107`	`107`	`set`
`@@ -112,7 +112,7 @@ public bool HasRotAngleZ`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`// Scale`
`115`		`- public bool HasScaleX`
	`115`	`+ internal bool HasScaleX`
`116`	`116`	`{`
`117`	`117`	`get => (m_Bitset & (1 << k_ScaleXBit)) != 0;`
`118`	`118`	`set`
`@@ -122,7 +122,7 @@ public bool HasScaleX`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`- public bool HasScaleY`
	`125`	`+ internal bool HasScaleY`
`126`	`126`	`{`
`127`	`127`	`get => (m_Bitset & (1 << k_ScaleYBit)) != 0;`
`128`	`128`	`set`
`@@ -132,7 +132,7 @@ public bool HasScaleY`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`135`		`- public bool HasScaleZ`
	`135`	`+ internal bool HasScaleZ`
`136`	`136`	`{`
`137`	`137`	`get => (m_Bitset & (1 << k_ScaleZBit)) != 0;`
`138`	`138`	`set`
`@@ -142,7 +142,7 @@ public bool HasScaleZ`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`		`- public bool IsTeleportingNextFrame`
	`145`	`+ internal bool IsTeleportingNextFrame`
`146`	`146`	`{`
`147`	`147`	`get => (m_Bitset & (1 << k_TeleportingBit)) != 0;`
`148`	`148`	`set`
`@@ -152,12 +152,12 @@ public bool IsTeleportingNextFrame`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`		`- public float PositionX, PositionY, PositionZ;`
`156`		`- public float RotAngleX, RotAngleY, RotAngleZ;`
`157`		`- public float ScaleX, ScaleY, ScaleZ;`
`158`		`- public double SentTime;`
	`155`	`+ internal float PositionX, PositionY, PositionZ;`
	`156`	`+ internal float RotAngleX, RotAngleY, RotAngleZ;`
	`157`	`+ internal float ScaleX, ScaleY, ScaleZ;`
	`158`	`+ internal double SentTime;`
`159`	`159`
`160`		`- public Vector3 Position`
	`160`	`+ internal Vector3 Position`
`161`	`161`	`{`
`162`	`162`	`get { return new Vector3(PositionX, PositionY, PositionZ); }`
`163`	`163`	`set`
`@@ -168,7 +168,7 @@ public Vector3 Position`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`- public Vector3 Rotation`
	`171`	`+ internal Vector3 Rotation`
`172`	`172`	`{`
`173`	`173`	`get { return new Vector3(RotAngleX, RotAngleY, RotAngleZ); }`
`174`	`174`	`set`
`@@ -179,7 +179,7 @@ public Vector3 Rotation`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`		`- public Vector3 Scale`
	`182`	`+ internal Vector3 Scale`
`183`	`183`	`{`
`184`	`184`	`get { return new Vector3(ScaleX, ScaleY, ScaleZ); }`
`185`	`185`	`set`
`@@ -795,8 +795,6 @@ private void Initialize()`
`795`	`795`	`}`
`796`	`796`	`}`
`797`	`797`
`798`		`- #region state set`
`799`		`-`
`800`	`798`	`/// <summary>`
`801`	`799`	`/// Directly sets a state on the authoritative transform.`
`802`	`800`	`/// This will override any changes made previously to the transform`
`@@ -856,7 +854,6 @@ private void SetStateServerRpc(Vector3 pos, Quaternion rot, Vector3 scale, bool`
`856`	`854`	`m_Transform.localScale = scale;`
`857`	`855`	`m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = shouldTeleport;`
`858`	`856`	`}`
`859`		`- #endregion`
`860`	`857`
`861`	`858`	`// todo this is currently in update, to be able to catch any transform changes. A FixedUpdate mode could be added to be less intense, but it'd be`
`862`	`859`	`// conditional to users only making transform update changes in FixedUpdate.`