示例#1
0
    public static MCOutputData Get(Vector3[] srcPosArray, Vector2[] srcNorm01Array, Vector2[] srcNorm2tArray, int srcIdx, int len)
    {
        MCOutputData ret;

        if (len > SurfExtractorsMan.c_vertsCnt4Pool)
        {
            Vector3[] pos    = new Vector3[len];
            Vector2[] norm01 = new Vector2[len];
            Vector2[] norm2t = new Vector2[len];
            int[]     indice = new int[len];
            Array.Copy(srcPosArray, srcIdx, pos, 0, len);
            Array.Copy(srcNorm01Array, srcIdx, norm01, 0, len);
            Array.Copy(srcNorm2tArray, srcIdx, norm2t, 0, len);
            Array.Copy(SurfExtractorsMan.s_indiceMax, indice, len);
            ret = new MCOutputData(pos, norm01, norm2t, indice);
            return(ret);
        }
        else
        {
            ret = s_dataPool.Get();
            Array.Copy(srcPosArray, srcIdx, ret._pos, 0, len);
            Array.Copy(srcNorm01Array, srcIdx, ret._norm01, 0, len);
            Array.Copy(srcNorm2tArray, srcIdx, ret._norm2t, 0, len);
            if (len == SurfExtractorsMan.c_vertsCnt4Pool)
            {
                ret._indice = SurfExtractorsMan.s_indice4Pool;
            }
            else if (ret._indice == null || len != ret._indice.Length)
            {
                ret._indice = new int[len];
                Array.Copy(SurfExtractorsMan.s_indiceMax, ret._indice, len);
            }
        }
        return(ret);
    }
示例#2
0
        /// <summary>
        /// Creates a <see cref="ReadOnlyMessageFragment"/> which represents string that should be preserved and not modified by any other pseudo methods.
        /// Fragments are created using an ObjectPool so they can be reused. Use <see cref="ReleaseFragment(MessageFragment)"/> to
        /// return the fragment or allow the Message to handle returning the fragment if it is part of <see cref="Fragments"/>.
        /// </summary>
        /// <param name="original">The source string.</param>
        /// <returns>A new fragment.</returns>
        public ReadOnlyMessageFragment CreateReadonlyTextFragment(string original)
        {
            var frag = GenericPool <ReadOnlyMessageFragment> .Get();

            frag.Initialize(this, original);
            return(frag);
        }
示例#3
0
        /// <summary>
        /// Creates a new <see cref="WritableMessageFragment"/> which represents a string.
        /// Fragments are created using an ObjectPool so they can be reused. Use <see cref="ReleaseFragment(MessageFragment)"/> to
        /// return the fragment or allow the Message to handle returning the fragment if it is part of <see cref="Fragments"/>.
        /// </summary>
        /// <param name="original">The source string.</param>
        /// <returns>A new fragment.</returns>
        public WritableMessageFragment CreateTextFragment(string original)
        {
            var frag = GenericPool <WritableMessageFragment> .Get();

            frag.Initialize(this, original);
            return(frag);
        }
示例#4
0
    public void SpawnNumber(int number, Color c)
    {
        GameObject damageNumber = pool.GetObject();

        ((RectTransform)damageNumber.transform).anchoredPosition = new Vector2(0, 0);
        TextMeshProUGUI tmpugui = damageNumber.GetComponent <TextMeshProUGUI>();

        tmpugui.SetText(number.ToString());
        tmpugui.faceColor = c;

        Color outline = Color.black;

        UpdateTimer ut = timers.Get();

        ut.Start(2,
                 () => { // finish
            pool.Return(damageNumber);
            timers.Return(ut);
        },
                 (percentComplete) => { // update
            c.a = 1 - percentComplete;
            tmpugui.faceColor    = c;
            outline.a            = c.a;
            tmpugui.outlineColor = outline;
        });
    }
示例#5
0
        /// <summary>
        /// Creates a new message to represent a piece of text.
        /// </summary>
        /// <param name="text">The source text.</param>
        /// <returns>A new Message instance.</returns>
        internal static Message CreateMessage(string text)
        {
            var message = GenericPool <Message> .Get();

            message.Fragments.Add(message.CreateTextFragment(text));
            message.Original = text;
            return(message);
        }
示例#6
0
        internal void WriteAsyncLogEvents(ArraySegment <AsyncLogEventInfo> logEventInfos, AsyncContinuation continuation)
        {
            if (logEventInfos.Count == 0)
            {
                continuation(null);
            }
            else
            {
                AsyncLogEventInfo[] wrappedLogEventInfos = null;
                try
                {
                    Counter counter;

                    GenericPool <ContinueWhenAll> continuePool = null;
                    int remaining = logEventInfos.Count;

                    if (this.LoggingConfiguration.PoolingEnabled())
                    {
                        counter              = this.LoggingConfiguration.PoolFactory.Get <Counter>();
                        continuePool         = this.LoggingConfiguration.PoolFactory.Get <GenericPool <ContinueWhenAll>, ContinueWhenAll>();
                        wrappedLogEventInfos = this.LoggingConfiguration.PoolFactory.Get <AsyncLogEventInfoArrayPool, AsyncLogEventInfo[]>().Get(logEventInfos.Count);
                    }
                    else
                    {
                        wrappedLogEventInfos = new AsyncLogEventInfo[logEventInfos.Count];
                        counter = new Counter();
                    }

                    counter.Reset(remaining);

                    for (int i = 0; i < logEventInfos.Count; ++i)
                    {
                        AsyncContinuation originalContinuation = logEventInfos.Array[i].Continuation;

                        ContinueWhenAll cont;
                        if (continuePool != null)
                        {
                            cont = continuePool.Get();
                            cont.Reset(counter, originalContinuation, continuation);
                            wrappedLogEventInfos[i] = logEventInfos.Array[i].LogEvent.WithContinuation(cont.Delegate);
                        }
                        else
                        {
                            cont = new ContinueWhenAll();
                        }
                        cont.Reset(counter, originalContinuation, continuation);
                        wrappedLogEventInfos[i] = logEventInfos.Array[i].LogEvent.WithContinuation(cont.Delegate);
                    }

                    this.WriteAsyncLogEvents(new ArraySegment <AsyncLogEventInfo>(wrappedLogEventInfos, 0, logEventInfos.Count));
                }
                finally
                {
                    this.LoggingConfiguration.PutBack(wrappedLogEventInfos);
                }
            }
        }
示例#7
0
        /// <inheritdoc cref="Message.CreateReadonlyTextFragment(string, int, int)"/>
        public ReadOnlyMessageFragment CreateReadonlyTextFragment(int start, int end)
        {
            var frag = GenericPool <ReadOnlyMessageFragment> .Get();

            var startIndex = m_StartIndex == -1 ? start : m_StartIndex + start;

            frag.Initialize(@Message, m_OriginalString, startIndex, end);
            return(frag);
        }
示例#8
0
    public static GameObject Get(object key)
    {
        ObjectItem item = objects.Get(key);

        if (item == null)
        {
            return(null);
        }

        return(Reset(item).gameObject);
    }
示例#9
0
    public static T Get <T>(object key) where T : Component
    {
        ObjectItem item = components.Get(key);

        if (item == null)
        {
            return(null);
        }

        return((T)Reset(item).component);
    }
    public static SurfExtractReqB45 Get(int chunkStamp, Block45OctNode chunkData, Action <SurfExtractReqB45> finHandler, int nVertsPerMesh = SurfExtractorsMan.c_vertsCntMax)
    {
        //SurfExtractReqB45 req = new SurfExtractReqB45 ();
        SurfExtractReqB45 req = s_reqPool.Get();

        req._chunkStamp    = chunkStamp;
        req._chunkData     = chunkData;
        req._nVertsPerMesh = nVertsPerMesh;
        req._finHandler    = finHandler;
        return(req);
    }
示例#11
0
        public static XRPass Create(XRPassCreateInfo createInfo)
        {
            XRPassUniversal pass = GenericPool <XRPassUniversal> .Get();

            pass.InitBase(createInfo);

            // Initialize fields specific to Universal
            pass.isLateLatchEnabled = false;
            pass.canMarkLateLatch   = false;
            pass.hasMarkedLateLatch = false;

            return(pass);
        }
示例#12
0
    public static SurfExtractReqMC Get(VFVoxelChunkData chunk, int nVertsPerMesh = SurfExtractorsMan.c_vertsCnt4Pool)
    {
        //SurfExtractReqMC req = new SurfExtractReqMC ();
        SurfExtractReqMC req = s_reqPool.Get();

        req._chunk            = chunk;
        req._chunkData        = chunk.DataVT;
        req._chunkSig         = chunk.SigOfChnk;
        req._chunkStamp       = chunk.StampOfUpdating;
        req._customFinHandler = null;
        req._nVertsPerMesh    = nVertsPerMesh;
        return(req);
    }
            public Set this[int index]
            {
                get
                {
                    if (!m_Requests.TryGetValue(index, out var v))
                    {
                        v = GenericPool <Set> .Get();

                        m_Requests.Add(index, v);
                    }
                    return(v);
                }
            }
示例#14
0
        /// <summary>
        /// Implementation for all versions of <see cref="GetLocalizedAssetAsync"/>.
        /// </summary>
        /// <typeparam name="TObject">The type of asset that should be loaded.</typeparam>
        /// <param name="tableReference">A reference to the table that the asset should be loaded from.</param>
        /// <param name="tableEntryReference">A reference to the entry in the table.</param>
        /// <param name="locale">The <see cref="Locale"/> to use instead of the default <see cref="LocalizationSettings.SelectedLocale"/></param>
        protected virtual AsyncOperationHandle <TObject> GetLocalizedAssetAsyncInternal <TObject>(TableReference tableReference, TableEntryReference tableEntryReference, Locale locale) where TObject : Object
        {
            var loadTableOperation = GetTableAsync(tableReference, locale);

            var operation = GenericPool <LoadAssetOperation <TObject> > .Get();

            operation.Init(loadTableOperation, tableEntryReference);
            var handle = AddressablesInterface.ResourceManager.StartOperation(operation, loadTableOperation);

            // We don't want to force users to have to manage the reference counting so by default we will release the operation for reuse once completed in the next frame
            // If a user wants to hold onto it then they should call Acquire on the operation and later Release.
            handle.CompletedTypeless += ReleaseNextFrame;

            return(handle);
        }
        public CreateChunkAndRenderBlock(
            World world,
            Dictionary <string, Texture> textureDictionary,
            string texturePath,
            RenderSettings renderSettings,
            IGraphicsApi <TImage> graphics,
            int chunkSize, int chunksPerDimension,
            ExecutionDataflowBlockOptions options)
        {
            int tileSize = chunksPerDimension * chunkSize;

            graphics.SetPoolDimensions(tileSize, tileSize);
            int chunkRenderedCounter = 0;
            var renderCombiPool      = new GenericPool <RendererCombi <TImage> >(() => new RendererCombi <TImage>(textureDictionary, texturePath, renderSettings, graphics));

            Block = new TransformBlock <IEnumerable <ChunkData>, ImageInfo <TImage> >(chunkDatas =>
            {
                RendererCombi <TImage> chunkRenderer = null;
                try
                {
                    var b = graphics.GetPooledImage(); // pooled
                    //var b = graphics.CreateEmptyImage(tileSize, tileSize);

                    chunkRenderer = renderCombiPool.Get();
                    var firstX    = -1;
                    var firstZ    = -1;

                    var count         = 0;
                    var chunkDataList = chunkDatas.ToList();
                    foreach (var chunkData in chunkDataList)
                    {
                        var chunk = world.GetChunk(chunkData.X, chunkData.Z, chunkData);

                        if (firstX == -1)
                        {
                            firstX = chunkData.X;
                        }
                        if (firstZ == -1)
                        {
                            firstZ = chunkData.Z;
                        }

                        var x = chunk.X % chunksPerDimension;
                        var z = chunk.Z % chunksPerDimension;
                        if (x < 0)
                        {
                            x += chunksPerDimension;
                        }
                        if (z < 0)
                        {
                            z += chunksPerDimension;
                        }
                        chunkRenderer.ChunkRenderer.RenderChunk(b, chunk, x * chunkSize, z * chunkSize);

                        world.ChunkPool?.Return(chunk);
                        count++;
                    }


                    var fx = CoordHelpers.GetGroupedCoordinate(firstX, chunksPerDimension);
                    var fz = CoordHelpers.GetGroupedCoordinate(firstZ, chunksPerDimension);

                    Interlocked.Increment(ref processedCount);
                    Interlocked.Add(ref chunkRenderedCounter, count);

                    if (chunkRenderedCounter >= 128)
                    {
                        var v = chunkRenderedCounter;
                        ChunksRendered?.Invoke(this, new ChunksRenderedEventArgs(v));
                        Interlocked.Add(ref chunkRenderedCounter, -v);
                    }

                    /*if (r.Next(100) == 0)
                     * {
                     *  throw new ArgumentOutOfRangeException("Test Error in CreateChunkAndRender");
                     * }*/



                    return(new ImageInfo <TImage>()
                    {
                        Image = b,
                        X = fx,
                        Z = fz,
                        Cd = chunkDataList.SelectMany(x => x.SubChunks)
                    });
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error in CreateChunkAndRenderBlock: " + ex.Message);
                    return(null);
                }
                finally
                {
                    if (chunkRenderer != null)
                    {
                        renderCombiPool.Return(chunkRenderer);
                    }
                }
            }, options);
        }
示例#16
0
        internal static void GetMenuOptions(int mask, string[] flagNames, int[] flagValues,
                                            out string buttonText, out string buttonMixedValuesText, out string[] optionNames, out int[] optionMaskValues, out int[] selectedOptions, Type enumType = null)
        {
            const int everythingValue   = ~0;
            bool      hasNothingName    = flagValues[0] == 0;
            bool      hasEverythingName = flagValues[flagValues.Length - 1] == everythingValue;

            var nothingName    = (hasNothingName ? flagNames[0] : "Nothing");
            var everythingName = (hasEverythingName ? flagNames[flagValues.Length - 1] : "Everything");

            var optionCount = flagNames.Length + (hasNothingName ? 0 : 1) + (hasEverythingName ? 0 : 1);
            var flagCount   = flagNames.Length - (hasNothingName ? 1 : 0) - (hasEverythingName ? 1 : 0);

            // These indices refer to flags that are not 0 and everythingValue
            var flagStartIndex = (hasNothingName ? 1 : 0);
            var flagEndIndex   = flagStartIndex + flagCount;

            // Options names
            optionNames    = GetBuffer(s_OptionNames, optionCount);
            optionNames[0] = nothingName;
            optionNames[1] = everythingName;
            for (var flagIndex = flagStartIndex; flagIndex < flagEndIndex; flagIndex++)
            {
                var optionIndex = flagIndex - flagStartIndex + 2;
                optionNames[optionIndex] = flagNames[flagIndex];
            }

            var flagMask         = 0; // Disjunction of all flags (except 0 and everythingValue)
            var intermediateMask = 0; // Mask used to compute new mask value for each options

            // Selected options
            s_SelectedOptionsSet.Clear();
            for (var flagIndex = flagStartIndex; flagIndex < flagEndIndex; flagIndex++)
            {
                var flagValue = flagValues[flagIndex];
                flagMask |= flagValue;
                if ((mask & flagValue) == flagValue)
                {
                    var optionIndex = flagIndex - flagStartIndex + 2;
                    s_SelectedOptionsSet.Add(optionIndex);
                    intermediateMask |= flagValue;
                }
            }

            // Button text
            buttonText            = null;
            buttonMixedValuesText = null;
            for (var flagIndex = flagStartIndex; flagIndex < flagEndIndex; flagIndex++)
            {
                // Check if a specific value is set.
                if (mask == flagValues[flagIndex])
                {
                    buttonText = flagNames[flagIndex];
                }
            }

            if (buttonText == null)
            {
                if (flagMask == intermediateMask)
                {
                    // If all of the available flags are set then show the Everything name.
                    s_SelectedOptionsSet.Add(1);
                    buttonText = everythingName;
                }
                else if (mask == 0 || s_SelectedOptionsSet.Count == 0)
                {
                    // If the mask is 0 or none of the actual flags are set we use the nothing name.
                    s_SelectedOptionsSet.Add(0);
                    buttonText = nothingName;
                }
                else
                {
                    buttonText = "Mixed...";

                    // Extract mixed labels
                    var sb = GenericPool <StringBuilder> .Get();

                    var iterator = s_SelectedOptionsSet.GetEnumerator();
                    iterator.MoveNext();

                    sb.Append(flagNames[iterator.Current + flagStartIndex - 2]);
                    while (iterator.MoveNext())
                    {
                        sb.Append(", ");
                        sb.Append(flagNames[iterator.Current + flagStartIndex - 2]);
                    }
                    buttonMixedValuesText = sb.ToString();

                    sb.Clear();
                    GenericPool <StringBuilder> .Release(sb);
                }
            }

            selectedOptions = GetBuffer(s_SelectedOptions, s_SelectedOptionsSet.Count);
            var x = 0;

            foreach (var selected in s_SelectedOptionsSet)
            {
                selectedOptions[x] = selected;
                ++x;
            }

            // Option mask values
            optionMaskValues    = GetBuffer(s_OptionValues, optionCount);
            optionMaskValues[0] = 0;
            optionMaskValues[1] = everythingValue;
            if (EditorGUI.showMixedValue)
            {
                intermediateMask = 0;
            }
            for (var flagIndex = flagStartIndex; flagIndex < flagEndIndex; flagIndex++)
            {
                var optionIndex = flagIndex - flagStartIndex + 2;
                var flagValue   = flagValues[flagIndex];
                var flagSet     = ((intermediateMask & flagValue) == flagValue);
                var newMask     = (flagSet ? intermediateMask & ~flagValue : intermediateMask | flagValue);

                // If all flag options are selected the mask becomes everythingValue to be consistent with the "Everything" option
                if (newMask == flagMask)
                {
                    newMask = everythingValue;
                }

                optionMaskValues[optionIndex] = newMask;
            }
        }
示例#17
0
        internal static void GetMaskButtonValue(int mask, string[] flagNames, int[] flagValues, out string buttonText, out string buttonMixedValuesText)
        {
            const int everythingValue   = ~0;
            bool      hasNothingName    = flagValues[0] == 0;
            bool      hasEverythingName = flagValues[flagValues.Length - 1] == everythingValue;

            var nothingName    = (hasNothingName ? flagNames[0] : "Nothing");
            var everythingName = (hasEverythingName ? flagNames[flagValues.Length - 1] : "Everything");

            var flagCount = flagNames.Length - (hasNothingName ? 1 : 0) - (hasEverythingName ? 1 : 0);

            var flagStartIndex = (hasNothingName ? 1 : 0);
            var flagEndIndex   = flagStartIndex + flagCount;

            var flagMask         = 0; // Disjunction of all flags (except 0 and everythingValue)
            var intermediateMask = 0; // Mask used to compute new mask value for each options
            var usedFlags        = ListPool <int> .Get();

            buttonText            = null;
            buttonMixedValuesText = null;

            for (var flagIndex = flagStartIndex; flagIndex < flagEndIndex; flagIndex++)
            {
                var flagValue = flagValues[flagIndex];
                flagMask |= flagValue;

                if (mask == flagValues[flagIndex])
                {
                    buttonText = flagNames[flagIndex];
                }

                if ((mask & flagValue) == flagValue)
                {
                    intermediateMask |= flagValue;
                    usedFlags.Add(flagIndex);
                }
            }

            if (buttonText == null)
            {
                if (flagMask == intermediateMask)
                {
                    // If all of the available flags are set then show the Everything name.
                    buttonText = everythingName;
                }
                else if (intermediateMask == 0)
                {
                    // If the mask is 0 or none of the actual flags are set we use the nothing name.
                    buttonText = nothingName;
                }
                else
                {
                    buttonText = "Mixed...";

                    // Extract mixed labels
                    var sb = GenericPool <StringBuilder> .Get();

                    sb.Append(flagNames[usedFlags[0]]);
                    for (int i = 1; i < usedFlags.Count; ++i)
                    {
                        sb.Append(", ");
                        sb.Append(flagNames[usedFlags[i]]);
                    }
                    buttonMixedValuesText = sb.ToString();

                    sb.Clear();
                    GenericPool <StringBuilder> .Release(sb);
                }
            }

            ListPool <int> .Release(usedFlags);
        }
示例#18
0
 public Bitmap GetPooledImage()
 {
     return(pool.Get());
 }