示例#1
0
        private void RenderFeatures_CollectionChanged(object sender, ref FastTrackingCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
            case NotifyCollectionChangedAction.Add:
                for (int index = 0; index < renderObjectsWithoutFeatures.Count; index++)
                {
                    var renderObject = renderObjectsWithoutFeatures[index];

                    // Try to reprocess object that didn't have any stage before
                    if (renderObject.RenderFeature == null)
                    {
                        RenderSystem.AddRenderObject(renderObject);
                        if (renderObject.RenderFeature != null)
                        {
                            renderObjectsWithoutFeatures.SwapRemoveAt(index--);
                            ReevaluateActiveRenderStages(renderObject);
                        }
                    }
                }
                break;

            case NotifyCollectionChangedAction.Remove:
                foreach (var renderObject in RenderObjects)
                {
                    if (renderObject.RenderFeature == e.Item)
                    {
                        RenderSystem.RemoveRenderObject(renderObject);
                        renderObjectsWithoutFeatures.Add(renderObject);
                    }
                }
                break;
            }
        }
示例#2
0
        internal bool RemoveRenderObject(List <RenderObject> renderObjects, RenderObject renderObject)
        {
            if (renderObject.RenderFeature == null)
            {
                renderObjectsWithoutFeatures.Remove(renderObject);
            }

            RenderSystem.RemoveRenderObject(renderObject);

            // Get and clear ordered node index
            var orderedRenderNodeIndex = renderObject.VisibilityObjectNode.Index;

            if (renderObject.VisibilityObjectNode == StaticObjectNodeReference.Invalid)
            {
                return(false);
            }

            renderObject.VisibilityObjectNode = StaticObjectNodeReference.Invalid;

            // SwapRemove each items in dataArrays
            RenderData.SwapRemoveItem(DataType.StaticObject, orderedRenderNodeIndex, renderObjects.Count - 1);

            // Remove entry from ordered node index
            renderObjects.SwapRemoveAt(orderedRenderNodeIndex);

            // If last item was moved, update its index
            if (orderedRenderNodeIndex < renderObjects.Count)
            {
                renderObjects[orderedRenderNodeIndex].VisibilityObjectNode = new StaticObjectNodeReference(orderedRenderNodeIndex);
            }

            return(true);
        }
示例#3
0
    // TODO: move this to OAExtensions
    private void MoveItem(List <OAPickupable> from, List <OAPickupable> to, int index, bool active)
    {
        var pickup = from[index];

        pickup.gameObject.SetActive(active);
        to.Add(pickup);
        from.SwapRemoveAt(index);
    }
示例#4
0
    private static bool AllowedStealing(InAudioNode audioNode, List <InstanceInfo> currentInstances)
    {
        var data = (InAudioNodeData)audioNode.NodeData;

        if (data.LimitInstances && currentInstances.Count >= data.MaxInstances)
        {
            InPlayer player    = null;
            var      stealType = data.InstanceStealingTypes;
            if (stealType == InstanceStealingTypes.NoStealing)
            {
                return(false);
            }

            int          index = 0;
            InstanceInfo foundInfo;
            if (stealType == InstanceStealingTypes.Newest)
            {
                double newestTime = 0;

                for (int i = 0; i < currentInstances.Count; i++)
                {
                    InstanceInfo instanceInfo = currentInstances[i];
                    if (instanceInfo.Timestamp > newestTime)
                    {
                        newestTime = instanceInfo.Timestamp;
                        index      = i;
                    }
                }
            }
            else if (stealType == InstanceStealingTypes.Oldest)
            {
                double oldestTime = Double.MaxValue;
                for (int i = 0; i < currentInstances.Count; i++)
                {
                    InstanceInfo instanceInfo = currentInstances[i];
                    if (instanceInfo.Timestamp < oldestTime)
                    {
                        oldestTime = instanceInfo.Timestamp;
                        index      = i;
                    }
                }
            }

            foundInfo = currentInstances[index];
            player    = foundInfo.Player;
            currentInstances.SwapRemoveAt(ref index);
            if (player != null)
            {
                player.Stop();
            }
        }
        return(true);
    }
        internal void RemoveRenderObject(RenderObject renderObject)
        {
            OnRemoveRenderObject(renderObject);

            // Get and clear ordered node index
            var orderedRenderNodeIndex = renderObject.StaticObjectNode.Index;

            renderObject.StaticObjectNode = StaticObjectNodeReference.Invalid;

            // SwapRemove each items in dataArrays
            RenderData.SwapRemoveItem(DataType.StaticObject, orderedRenderNodeIndex, RenderObjects.Count - 1);

            // Remove entry from ordered node index
            RenderObjects.SwapRemoveAt(orderedRenderNodeIndex);

            // If last item was moved, update its index
            if (orderedRenderNodeIndex < RenderObjects.Count)
            {
                RenderObjects[orderedRenderNodeIndex].StaticObjectNode = new StaticObjectNodeReference(orderedRenderNodeIndex);
            }

            // Detach render feature
            renderObject.RenderFeature = null;
        }
示例#6
0
        internal bool RemoveRenderObject(List<RenderObject> renderObjects, RenderObject renderObject)
        {
            if (renderObject.RenderFeature == null)
                renderObjectsWithoutFeatures.Remove(renderObject);

            RenderSystem.RemoveRenderObject(renderObject);

            // Get and clear ordered node index
            var orderedRenderNodeIndex = renderObject.VisibilityObjectNode.Index;
            if (renderObject.VisibilityObjectNode == StaticObjectNodeReference.Invalid)
                return false;

            renderObject.VisibilityObjectNode = StaticObjectNodeReference.Invalid;

            // SwapRemove each items in dataArrays
            RenderData.SwapRemoveItem(DataType.StaticObject, orderedRenderNodeIndex, renderObjects.Count - 1);

            // Remove entry from ordered node index
            renderObjects.SwapRemoveAt(orderedRenderNodeIndex);

            // If last item was moved, update its index
            if (orderedRenderNodeIndex < renderObjects.Count)
            {
                renderObjects[orderedRenderNodeIndex].VisibilityObjectNode = new StaticObjectNodeReference(orderedRenderNodeIndex);
            }

            return true;
        }
示例#7
0
        private static bool AllowedStealing(InAudioNode audioNode, List<InstanceInfo> currentInstances)
        {
            var data = (InAudioNodeData) audioNode._nodeData;
            if (data.LimitInstances && currentInstances.Count >= data.MaxInstances)
            {
                InPlayer player = null;
                var stealType = data.InstanceStealingTypes;
                if (stealType == InstanceStealingTypes.NoStealing)
                    return false;

                int index = 0;
                InstanceInfo foundInfo;
                if (stealType == InstanceStealingTypes.Newest)
                {
                    double newestTime = 0;

                    for (int i = 0; i < currentInstances.Count; i++)
                    {
                        InstanceInfo instanceInfo = currentInstances[i];
                        if (instanceInfo.Timestamp > newestTime)
                        {
                            newestTime = instanceInfo.Timestamp;
                            index = i;
                        }
                    }
                }
                else if (stealType == InstanceStealingTypes.Oldest)
                {
                    double oldestTime = Double.MaxValue;
                    for (int i = 0; i < currentInstances.Count; i++)
                    {
                        InstanceInfo instanceInfo = currentInstances[i];
                        if (instanceInfo.Timestamp < oldestTime)
                        {
                            oldestTime = instanceInfo.Timestamp;
                            index = i;
                        }
                    }
                }

                foundInfo = currentInstances[index];
                player = foundInfo.Player;
                currentInstances.SwapRemoveAt(ref index);
                if (player != null)
                    player.Stop();
            }
            return true;
        }