void SetAlphaForProxies(MyInstanceLodId id, MyLodTransitionData data)
        {
            ProfilerShort.Begin("SetAlphaForProxies");
            var instance = m_instances[id];

            if (data.IsProxyToInstance)
            {
                float value      = GetAlphaForTime(data.Time, data.Delta > 0);
                float otherValue = GetAlphaForTime(data.Time, data.Delta < 0);

                var lod = instance.Lods[instance.CurrentLod];
                foreach (var proxy in lod.RenderableProxies)
                {
                    proxy.CommonObjectData.CustomAlpha = value;
                }
            }
            else
            {
                float valueForStartLod = GetAlphaForTime(data.Time, true);
                float valueForEndLod   = GetAlphaForTime(data.Time, false);

                var startLod = instance.Lods[instance.CurrentLod];
                var endLod   = instance.Lods[instance.CurrentLod + Math.Sign(data.Delta)];
                foreach (var renderableProxy in startLod.RenderableProxies)
                {
                    renderableProxy.CommonObjectData.CustomAlpha = valueForStartLod;
                }
                foreach (var renderableProxy in endLod.RenderableProxies)
                {
                    renderableProxy.CommonObjectData.CustomAlpha = valueForEndLod;
                }
            }
            ProfilerShort.End();
        }
        internal void SetLod(InstancingId id, int index, int lod)
        {
            MySingleInstance instance;
            var key = new MyInstanceLodId {
                Id = id, InstanceIndex = index
            };

            if (m_instances.TryGetValue(key, out instance) && instance.CurrentLod != lod)
            {
                MyLodTransitionData transition;
                if (m_activeTransitions.TryGetValue(key, out transition))
                {
                    if (transition.IsProxyToInstance)
                    {
                        instance.CurrentLod = lod;
                        instance.IsDirty    = true;
                    }
                }
                else
                {
                    transition                   = new MyLodTransitionData();
                    transition.Delta             = instance.CurrentLod > lod ? -0.1f : 0.1f;
                    transition.Time              = 0.0f;
                    transition.IsProxyToInstance = false;
                    m_activeTransitions.Add(key, transition);
                    instance.IsDirty = true;
                }
            }
        }
        void RemoveTransition(MyInstanceLodId instanceLodId)
        {
            MyLodTransitionData transitionData = null;

            if (m_activeTransitions.TryGetValue(instanceLodId, out transitionData))
            {
                MyObjectPoolManager.Deallocate(transitionData);
                m_activeTransitions.Remove(instanceLodId);
            }
        }
        /// <returns>Returns true if the item is in transition</returns>
        bool SetDelta(InstancingId id, int index, float delta)
        {
            var key = new MyInstanceLodId {
                Id = id, InstanceIndex = index
            };
            MyLodTransitionData data;

            if (m_activeTransitions.TryGetValue(key, out data))
            {
                data.Delta             = delta;
                data.Time              = 0;
                data.IsProxyToInstance = true;
                return(true);
            }
            else
            {
                data = new MyLodTransitionData {
                    Time = 0.0f, Delta = delta, IsProxyToInstance = true
                };
                m_activeTransitions.Add(key, data);
                return(false);
            }
        }
 internal void SetLod(InstancingId id, int index, int lod)
 {
     MySingleInstance instance;
     var key = new MyInstanceLodId { Id = id, InstanceIndex = index };
     if (m_instances.TryGetValue(key, out instance) && instance.CurrentLod != lod)
     {
         MyLodTransitionData transition;
         if (m_activeTransitions.TryGetValue(key, out transition))
         {
             if (transition.IsProxyToInstance)
             {
                 instance.CurrentLod = lod;
                 instance.IsDirty = true;
             }
         }
         else
         {
             transition = new MyLodTransitionData();
             transition.Delta = instance.CurrentLod > lod ? -0.1f : 0.1f;
             transition.Time = 0.0f;
             transition.IsProxyToInstance = false;
             m_activeTransitions.Add(key, transition);
             instance.IsDirty = true;
         }
     }
 }
 /// <returns>Returns true if the item is in transition</returns>
 bool SetDelta(InstancingId id, int index, float delta)
 {
     var key = new MyInstanceLodId { Id = id, InstanceIndex = index };
     MyLodTransitionData data;
     if (m_activeTransitions.TryGetValue(key, out data))
     {
         data.Delta = delta;
         data.Time = 0;
         data.IsProxyToInstance = true;
         return true;
     }
     else
     {
         data = new MyLodTransitionData { Time = 0.0f, Delta = delta, IsProxyToInstance = true };
         m_activeTransitions.Add(key, data);
         return false;
     }
 }
        void SetAlphaForProxies(MyInstanceLodId id, MyLodTransitionData data)
        {
            var instance = m_instances[id];
            if (data.IsProxyToInstance)
            {
                float value = GetAlphaForTime(data.Time, data.Delta > 0);
                float otherValue = GetAlphaForTime(data.Time, data.Delta < 0);

                var lod = instance.Lods[instance.CurrentLod];
                foreach (var proxy in lod.RenderableProxies)
                {
                    proxy.ObjectData.CustomAlpha = value;
                }
            }
            else
            {
                float valueForStartLod = GetAlphaForTime(data.Time, true);
                float valueForEndLod = GetAlphaForTime(data.Time, false);

                var startLod = instance.Lods[instance.CurrentLod];
                var endLod = instance.Lods[instance.CurrentLod + Math.Sign(data.Delta)];
                foreach (var proxy in startLod.RenderableProxies)
                {
                    proxy.ObjectData.CustomAlpha = valueForStartLod;
                }
                foreach (var proxy in endLod.RenderableProxies)
                {
                    proxy.ObjectData.CustomAlpha = valueForEndLod;
                }
            }
        }
 public static void Cleanup(MyLodTransitionData transitionData)
 {
     transitionData.Cleanup();
 }