decentraland · NickKhalow · Aug 13, 2026 · Aug 7, 2026 · Aug 7, 2026 · Aug 7, 2026
@@ -87,6 +87,23 @@ public void RegisterAvatar(AvatarBase avatarBase, ref AvatarTransformMatrixCompo
             remoteAvatars.Register(avatarBase, ref transformMatrixComponent);
         }
 
+        /// <summary>
+        ///     Pushes the avatar's authoritative bone count (AvatarCustomSkinningComponent.BoneCount — the
+        ///     exact number of matrices ComputeSkinning uploads) into the matching pipeline so the
+        ///     calculation job produces precisely that range. Must be called every frame before
+        ///     ScheduleBoneMatrixCalculation; unregistered avatars (invalid index) are ignored.
+        /// </summary>
+        public void SetBoneCount(ref AvatarTransformMatrixComponent transformMatrixComponent, int boneCount)
+        {
+            if (transformMatrixComponent.IndexInGlobalJobArray.TryGetValue(out int validIndex) == false)
+                return;
+
+            if (transformMatrixComponent.IsMainPlayer)
+                mainPlayerAvatar.SetBoneCount(boneCount);
+            else
+                remoteAvatars.SetBoneCount(validIndex, boneCount);
+        }
+
         public void Dispose()
         {
             // Leak the resouces. Managed dispose of TransformAccessArray takes very much time.

@@ -24,6 +24,8 @@ internal class MainPlayerPipeline : IDisposable
         private NativeArray<float4x4> avatarMatrix;
         private NativeArray<bool> updateFlag;
 
+        private NativeArray<int> perAvatarBoneCount;
+
         public BoneMatrixCalculationJob Job;
 
         internal MainPlayerPipeline(int bonesArrayLength)
@@ -34,9 +36,19 @@ internal MainPlayerPipeline(int bonesArrayLength)
             bonesCombined = new NativeArray<float4x4>(bonesArrayLength, Allocator.Persistent);
             avatarMatrix = new NativeArray<float4x4>(1, Allocator.Persistent);
             updateFlag = new NativeArray<bool>(1, Allocator.Persistent);
+            perAvatarBoneCount = new NativeArray<int>(1, Allocator.Persistent) { [0] = bonesArrayLength };
             Job = new BoneMatrixCalculationJob(bonesArrayLength, bonesArrayLength, bonesCombined);
         }
 
+        /// <summary>
+        ///     Refreshes the matrix count for the main player from the authoritative
+        ///     AvatarCustomSkinningComponent.BoneCount. Called every frame before ScheduleAndComplete.
+        /// </summary>
+        public void SetBoneCount(int boneCount)
+        {
+            perAvatarBoneCount[0] = boneCount;
+        }
+
         public void Register(Transform rootTransform, BoneArray bones, Transform dummyTransform)
         {
             updateFlag[0] = true;
@@ -76,6 +88,7 @@ public void ScheduleAndComplete()
 
             Job.AvatarTransform = avatarMatrix;
             Job.UpdateAvatar = updateFlag;
+            Job.PerAvatarBoneCount = perAvatarBoneCount;
             var calcHandle = Job.Schedule(1, 1, gatherHandle);
             calcHandle.Complete(); // Fast — 1 avatar, 62 bones. Unlocks main player transforms.
         }
@@ -85,6 +98,7 @@ public void Dispose()
             bonesCombined.Dispose();
             avatarMatrix.Dispose();
             updateFlag.Dispose();
+            perAvatarBoneCount.Dispose();
             Job.Dispose();
 
             if (bonesTA.isCreated) bonesTA.Dispose();

@@ -30,6 +30,8 @@ internal class RemoteAvatarPipeline : IDisposable
         private QuickArray<bool> updateAvatar;
         private QuickArray<float4x4> bonesCombined;
 
+        private QuickArray<int> perAvatarBoneCount;
+
         private Transform[] flatBones;
         private Transform[] flatRoots;
 
@@ -61,6 +63,9 @@ internal RemoteAvatarPipeline(int initialCapacity, int bonesArrayLength, int bon
             matrixFromAllAvatars = new QuickArray<float4x4>(initialCapacity);
             updateAvatar = new QuickArray<bool>(initialCapacity);
 
+            perAvatarBoneCount = new QuickArray<int>(initialCapacity);
+            FillWithStride(perAvatarBoneCount, 0, initialCapacity, bonesArrayLength);
+
             flatBones = new Transform[initialCapacity * bonesArrayLength];
             flatRoots = new Transform[initialCapacity];
             FillWithDummy(flatBones, 0, flatBones.Length, dummyTransform);
@@ -152,6 +157,19 @@ public void Release(ref AvatarTransformMatrixComponent avatarTransformMatrixComp
             avatarTransformMatrixComponent.IndexInGlobalJobArray = GlobalJobArrayIndex.Unassign();
         }
 
+        /// <summary>
+        ///     Refreshes the per-avatar matrix count for a live slot from the authoritative
+        ///     AvatarCustomSkinningComponent.BoneCount. Called every frame (before Schedule) so a
+        ///     wearable re-equip that changes the bone count is reflected without needing a re-register.
+        /// </summary>
+        public void SetBoneCount(int validIndex, int boneCount)
+        {
+            if (validIndex < 0 || validIndex >= perAvatarBoneCount.Length)
+                return;
+
+            perAvatarBoneCount[validIndex] = boneCount;
+        }
+
         public void Schedule(int batchCount)
         {
             if (avatarIndex == 0)
@@ -173,6 +191,7 @@ public void Schedule(int batchCount)
 
             Job.AvatarTransform = matrixFromAllAvatars.InnerNativeArray();
             Job.UpdateAvatar = updateAvatar.InnerNativeArray();
+            Job.PerAvatarBoneCount = perAvatarBoneCount.InnerNativeArray();
             handle = Job.Schedule(avatarIndex, batchCount, combinedGatherHandle);
         }
 
@@ -203,6 +222,10 @@ private void ResizeArrays()
             matrixFromAllAvatars.ReAlloc(newCapacity);
             updateAvatar.ReAlloc(newCapacity);
 
+            int oldCapacity = currentAvatarAmountSupported;
+            perAvatarBoneCount.ReAlloc(newCapacity);
+            FillWithStride(perAvatarBoneCount, oldCapacity, newCapacity - oldCapacity, bonesArrayLength);
+
             int oldBonesLength = flatBones.Length;
             int oldRootsLength = flatRoots.Length;
 
@@ -225,6 +248,12 @@ private static void FillWithDummy(Transform[] array, int startIndex, int count,
                 array[i] = dummy;
         }
 
+        private static void FillWithStride(QuickArray<int> array, int startIndex, int count, int value)
+        {
+            for (int i = startIndex; i < startIndex + count; i++)
+                array[i] = value;
+        }
+
         public void Dispose()
         {
             // Leak the resouces. Managed dispose of TransformAccessArray takes very much time.
@@ -244,6 +273,9 @@ public void Dispose()
             updateAvatar.Dispose();
             stopwatch.LogStep("updateAvatar.Dispose");
 
+            perAvatarBoneCount.Dispose();
+            stopwatch.LogStep("perAvatarBoneCount.Dispose");
+
             Job.Dispose();
             stopwatch.LogStep("job.Dispose");
 

@@ -9,7 +9,7 @@ namespace DCL.AvatarRendering.AvatarShape.ComputeShader
     [BurstCompile]
     public struct BoneMatrixCalculationJob : IJobParallelFor, IDisposable
     {
-        private readonly int boneCount;
+        private readonly int boneStride;
 
         [NativeDisableParallelForRestriction]
         private NativeArray<float4x4> bonesMatricesResult;
@@ -20,14 +20,17 @@ public struct BoneMatrixCalculationJob : IJobParallelFor, IDisposable
 
         [NativeDisableParallelForRestriction] public NativeArray<bool> UpdateAvatar;
 
+        [ReadOnly] [NativeDisableParallelForRestriction] public NativeArray<int> PerAvatarBoneCount;
+
         public NativeArray<float4x4> BonesMatricesResult => bonesMatricesResult;
 
-        public BoneMatrixCalculationJob(int boneCount, int bonesPerAvatarLength, NativeArray<float4x4> boneWorldMatrixArray)
+        public BoneMatrixCalculationJob(int boneStride, int bonesPerAvatarLength, NativeArray<float4x4> boneWorldMatrixArray)
         {
-            this.boneCount = boneCount;
+            this.boneStride = boneStride;
             bonesMatricesResult = new NativeArray<float4x4>(bonesPerAvatarLength, Allocator.Persistent);
             AvatarTransform = default;
             UpdateAvatar = default;
+            PerAvatarBoneCount = default;
 
             this.boneWorldMatrixArray = boneWorldMatrixArray;
         }
@@ -45,9 +48,10 @@ public void Execute(int avatarIdx)
                 return;
 
             float4x4 avatarMatrix = AvatarTransform[avatarIdx];
-            int offset = avatarIdx * boneCount;
+            int offset = avatarIdx * boneStride;
+            int count = math.min(PerAvatarBoneCount[avatarIdx], boneStride);
 
-            for (int b = 0; b < boneCount; b++)
+            for (int b = 0; b < count; b++)
                 bonesMatricesResult[offset + b] = math.mul(avatarMatrix, boneWorldMatrixArray[offset + b]);
         }
     }

@@ -22,6 +22,8 @@ namespace DCL.AvatarRendering.AvatarShape
     public partial class AvatarShapeVisibilitySystem : BaseUnityLoopSystem
     {
         private readonly RendererFeature_AvatarOutline? outlineFeature;
+        // Reused frustum-plane scratch buffer: rewritten once per tick in Update (CalculateFrustumPlanes) before the
+        // outline query reads it. Owned by the single-threaded ECS Update — NOT safe for concurrent callers.
         private readonly Plane[] planes;
         private readonly float startFadeDithering;
         private readonly float endFadeDithering;
@@ -60,15 +62,25 @@ protected override void Update(float t)
             BanAvatarsQuery(World);
             UpdateAvatarsVisibilityStateQuery(World);
             UpdateMainPlayerAvatarVisibilityStateQuery(World, camera.GetCameraComponent(World));
-            GetAvatarsVisibleWithOutlineQuery(World);
+
+            if (outlineFeature != null && outlineFeature.isActive)
+            {
+                CameraComponent cameraComponent = camera.GetCameraComponent(World);
+                CalculateFrustumPlanes(cameraComponent.Camera);
+                GetAvatarsVisibleWithOutlineQuery(World, cameraComponent);
+            }
         }
 
-        public bool IsVisibleInCamera(Camera camera, Bounds bounds)
+        internal void CalculateFrustumPlanes(Camera camera)
         {
             GeometryUtility.CalculateFrustumPlanes(camera, planes);
-            return GeometryUtility.TestPlanesAABB(planes, bounds);
         }
 
+        // Tests the AABB against the frustum planes cached by the most recent CalculateFrustumPlanes call.
+        // Extraction runs once per tick in Update (not per avatar), so this does not recompute the planes.
+        internal bool IsVisibleInCamera(Bounds bounds) =>
+            GeometryUtility.TestPlanesAABB(planes, bounds);
+
         public bool IsWithinCameraDistance(Camera camera, Transform objectTransform, float maxDistancesquared)
         {
             var diff = camera.transform.position - objectTransform.position;
@@ -77,9 +89,9 @@ public bool IsWithinCameraDistance(Camera camera, Transform objectTransform, flo
         }
 
         [Query]
-        private void GetAvatarsVisibleWithOutline(in AvatarBase avatarBase, ref AvatarShapeComponent avatarShape)
+        private void GetAvatarsVisibleWithOutline([Data] in CameraComponent cameraComponent, in AvatarBase avatarBase, ref AvatarShapeComponent avatarShape)
         {
-            if (outlineFeature != null && outlineFeature.isActive && (avatarShape.IsPreview || IsWithinCameraDistance(camera.GetCameraComponent(World).Camera, avatarBase.HeadAnchorPoint, 64.0f) && IsVisibleInCamera(camera.GetCameraComponent(World).Camera, avatarBase.AvatarSkinnedMeshRenderer.bounds)))
+            if (avatarShape.IsPreview || (IsWithinCameraDistance(cameraComponent.Camera, avatarBase.HeadAnchorPoint, 64.0f) && IsVisibleInCamera(avatarBase.AvatarSkinnedMeshRenderer.bounds)))
             {
                 RendererFeature_AvatarOutline.m_AvatarOutlineRenderers.AddRange(avatarShape.OutlineCompatibleRenderers);
             }
@@ -159,18 +171,21 @@ private void BanAvatars(in Entity entity, ref AvatarShapeComponent avatarShapeCo
             SetHiddenComponent(entity, isBanned, HiddenPlayerComponent.HiddenReason.Banned);
         }
 
-        private void SetHiddenComponent(Entity entity, bool hiddenValue, HiddenPlayerComponent.HiddenReason hiddenReason)
+        // Bitwise test in place of Enum.HasFlag, which boxes receiver and argument on Mono/IL2CPP (no
+        // intrinsic elision) — two heap allocations per test on this per-frame tick. Relies on callers
+        // passing a single flag: "& != 0" means ANY bit set, whereas HasFlag means ALL bits set.
+        internal void SetHiddenComponent(Entity entity, bool hiddenValue, HiddenPlayerComponent.HiddenReason hiddenReason)
         {
             ref HiddenPlayerComponent attachedHiddenComponent = ref World.TryGetRef<HiddenPlayerComponent>(entity, out bool isHiddenComponentAttached);
 
-            if (hiddenValue && (!isHiddenComponentAttached || (isHiddenComponentAttached && !attachedHiddenComponent.Reason.HasFlag(hiddenReason))))
+            if (hiddenValue && (!isHiddenComponentAttached || (isHiddenComponentAttached && (attachedHiddenComponent.Reason & hiddenReason) == 0)))
             {
                 if (!isHiddenComponentAttached)
                     World.Add(entity, new HiddenPlayerComponent { Reason = hiddenReason } );
                 else
                     attachedHiddenComponent.Reason |= hiddenReason;
             }
-            else if (!hiddenValue && isHiddenComponentAttached && attachedHiddenComponent.Reason.HasFlag(hiddenReason))
+            else if (!hiddenValue && isHiddenComponentAttached && (attachedHiddenComponent.Reason & hiddenReason) != 0)
             {
                 attachedHiddenComponent.Reason &= ~hiddenReason;
                 if (attachedHiddenComponent.Reason == 0)

@@ -29,6 +29,9 @@ protected override void Update(float t)
         {
             RegisterMainPlayerQuery(World);
             RegisterRemoteAvatarsQuery(World);
+
+            RefreshBoneCountsQuery(World);
+
             avatarTransformMatrixBatchJob.ScheduleBoneMatrixCalculation();
         }
 
@@ -54,5 +57,12 @@ private void RegisterRemoteAvatars(ref AvatarBase avatarBase, ref AvatarTransfor
 
             avatarTransformMatrixBatchJob.RegisterAvatar(avatarBase, ref transformMatrixComponent);
         }
+
+        [Query]
+        [None(typeof(DeleteEntityIntention))]
+        private void RefreshBoneCounts(ref AvatarTransformMatrixComponent transformMatrixComponent, ref AvatarCustomSkinningComponent skinningComponent)
+        {
+            avatarTransformMatrixBatchJob.SetBoneCount(ref transformMatrixComponent, skinningComponent.BoneCount);
+        }
     }
 }