예제 #1
0
파일: Output.cs 프로젝트: jiahao42/weverca
        /// <summary>
        /// Gets a content of buffers on current buffering level converted to string regardless of its type.
        /// </summary>
        /// <returns>
        /// The content converted to a string. Binary data are converted using <see cref="Encoding"/>.
        /// </returns>
        public string GetContentAsString()
        {
            if (level == null)
            {
                return(null);
            }

            StringBuilder result = new StringBuilder(level.size, level.size);

            for (int i = 0; i < level.buffers.Count; i++)
            {
                BufferElement element = (BufferElement)level.buffers[i];

                byte[] bytes = element.data as byte[];
                if (bytes != null)
                {
                    result.Append(encoding.GetString(bytes, 0, element.size));
                }
                else
                {
                    result.Append((char[])element.data, 0, element.size);
                }
            }
            return(result.ToString());
        }
예제 #2
0
        /// <summary>
        /// Loads the configuration properties from the application
        /// configuration.
        /// </summary>
        public static void Load()
        {
            ConfigSection section = (ConfigSection)
                                    ConfigurationManager.GetSection("x2net");

            TraceLevel        = section.Trace.Level;
            HeartbeatInterval = section.Heartbeat.Interval;

            FlowLoggingElement logging = section.Flow.Logging;

            Flow.Logging.SlowHandler.TraceLevel = logging.SlowHandler.TraceLevel;
            Flow.Logging.SlowHandler.Threshold  = logging.SlowHandler.Threshold;
            Flow.Logging.LongQueue.TraceLevel   = logging.LongQueue.TraceLevel;
            Flow.Logging.LongQueue.Threshold    = logging.LongQueue.Threshold;

            MaxLinkHandles = section.Link.MaxHandles;

            BufferElement buffer = section.Buffer;

            Buffer.SizeExponent.Chunk   = buffer.SizeExponent.Chunk;
            Buffer.SizeExponent.Segment = buffer.SizeExponent.Segment;
            Buffer.RoomFactor.MinLevel  = buffer.RoomFactor.MinLevel;
            Buffer.RoomFactor.MaxLevel  = buffer.RoomFactor.MaxLevel;

            Coroutine.MaxWaitHandles = section.Coroutine.MaxWaitHandles;
            Coroutine.DefaultTimeout = section.Coroutine.DefaultTimeout;
        }
예제 #3
0
        public void CreateBufferElement(ShaderDataType type, int size)
        {
            var bufferElement = new BufferElement(type, "Test");

            Assert.Equal(size, bufferElement.Size);
            Assert.Equal("Test", bufferElement.Name);
            Assert.False(bufferElement.Normalized);
        }
예제 #4
0
        public override void SetLayout(BufferLayout bufferLayout)
        {
            this.layout = bufferLayout;
            List <BufferElement> layout = bufferLayout.GetLayout();

            for (int i = 0; i < layout.Count; i++)
            {
                BufferElement element = layout[i];
                Gl.EnableVertexAttribArray(i);
                Gl.VertexAttribPointer((uint)i, (int)element.count, (VertexAttribPointerType)element.type, element.normalized, (int)bufferLayout.GetStride(), new IntPtr(element.offset));
            }
        }
예제 #5
0
 private void TransformPoints(float scale, Vector2 add)
 {
     for (var i = 0; i < _points.Length; i++)
     {
         var f = (_points[i].Vertex.X / scale) + add.X;
         if (f < -1)
         {
             f += 2;
         }
         _points[i] = new BufferElement(new Vector2(f, (_points[i].Vertex.Y / scale) + add.Y), _points[i].Color);
     }
 }
예제 #6
0
        public void CreateBufferLayout(int count)
        {
            const ShaderDataType type = ShaderDataType.Float;
            var typeSize = BufferElement.ShaderDataTypeSize(type);

            var bufferElements = new BufferElement[count];

            for (int i = 0; i < count; i++)
            {
                bufferElements[i] = new BufferElement(ShaderDataType.Float, "Test");
            }

            IBufferLayout bufferLayout = new OpenGLBufferLayout(bufferElements);

            Assert.NotNull(bufferLayout.Elements);
            Assert.Equal(count, bufferLayout.Elements.Count());
            Assert.Equal(count * typeSize, bufferLayout.Stride);
        }
예제 #7
0
파일: Output.cs 프로젝트: jiahao42/weverca
        /// <summary>
        /// Gets a content of buffers on current buffering level.
        /// </summary>
        /// <returns>The content as <see cref="string"/> or <see cref="PhpBytes"/> or a
        /// <b>null</b> reference if output buffering is disable.</returns>
        /// <remarks>
        /// Character data are returned unchanged, binary data are converted to string by
        /// the <see cref="System.Text.Encoding.GetString"/> method of the current encoding.
        /// </remarks>
        public object GetContent()
        {
            if (level == null)
            {
                return(null);
            }
            if (level.size == 0)
            {
                return(String.Empty);
            }

            // contains characters only:
            if (!level.containsByteData)
            {
                StringBuilder result = new StringBuilder(level.size, level.size);

                for (int i = 0; i < level.buffers.Count; i++)
                {
                    BufferElement element = (BufferElement)level.buffers[i];
                    result.Append((char[])element.data, 0, element.size);
                }
                return(result.ToString());
            }
            else
            // contains bytes only:
            if (!level.containsCharData)
            {
                var result = new byte[level.size];

                for (int i = 0, k = 0; i < level.buffers.Count; i++)
                {
                    BufferElement element = (BufferElement)level.buffers[i];
                    Array.Copy(element.data, 0, result, k, element.size);
                    k += element.size;
                }
                return(new PhpBytes(result));
            }
            else
            // contains both bytes and characters:
            {
                return(GetContentAsString());
            }
        }
예제 #8
0
        /// <summary>
        /// Flushes data on current level of buffering to the sinks or to the previous level.
        /// The current level clean up MUST follow this method's call.
        /// </summary>
        internal void InternalFlush()
        {
            Debug.Assert(_level != null);

            if (_level.filter == null)
            {
                if (_level.Index == 0)
                {
                    // TODO: PhpString buffers

                    // writes top-level data to sinks:
                    for (int i = 0; i < _level.buffers.Count; i++)
                    {
                        BufferElement element = _level.buffers[i];

                        byte[] bytes = element.data as byte[];
                        if (bytes != null)
                        {
                            _byteSink.Write(bytes, 0, element.size);
                        }
                        else
                        {
                            _charSink.Write((char[])element.data, 0, element.size);
                        }
                    }
                }
                else
                {
                    // joins levels (data are not copied => the current level MUST be cleaned up after the return from this method):
                    if (_level.size > 0)
                    {
                        var lower_level = _levels[_level.Index - 1];

                        lower_level.buffers.AddRange(_level.buffers);
                        lower_level.size             += _level.size;
                        lower_level.freeSpace         = _level.freeSpace; // free space in the last buffer of the level
                        lower_level.containsByteData |= _level.containsByteData;
                        lower_level.containsCharData |= _level.containsCharData;
                    }
                }
            }
            else
            {
                // gets data from user's callback:
                var data = _level.filter.DynamicInvoke(GetContent(), ChunkPosition.First | ChunkPosition.Middle | ChunkPosition.Last);
                if (data != null)
                {
                    var bindata = data as byte[];

                    // writes data to the current level of buffering or to sinks depending on the level count:
                    if (_level.Index == 0)
                    {
                        // checks whether the filtered data are binary at first; if not so, converts them to a string:

                        if (bindata != null)
                        {
                            _byteSink.Write(bindata, 0, bindata.Length);
                        }
                        else
                        {
                            // TODO: PhpString containing both string and byte[]
                            _charSink.Write(data.ToString());
                        }
                    }
                    else
                    {
                        // temporarily decreases the level of buffering toredirect writes to the lower level:
                        var old_level = _level;
                        _level = _levels[_level.Index - 1];

                        // checks whether the filtered data are binary at first; if not so, converts them to a string:
                        if (bindata != null)
                        {
                            _stream.Write(bindata, 0, bindata.Length);
                        }
                        else
                        {
                            // TODO: PhpString containing both string and byte[]
                            this.Write(data.ToString());
                        }

                        // restore the level of buffering:
                        _level = old_level;
                    }
                }
            }
        }
예제 #9
0
        ///// <summary>
        ///// Creates an instance of <see cref="BufferedOutput"/> having enabled buffering and with sinks set to null sinks.
        ///// </summary>
        //public BufferedOutput()
        //    : this(true, TextWriter.Null, System.IO.Stream.Null, Configuration.Application.Globalization.PageEncoding)
        //{
        //}

        #endregion

        #region Buffer allocation, level changing

        /// <summary>
        /// Gets a buffer where data of requested size and type can be stored.
        /// </summary>
        /// <param name="sizeNeeded">The number of characters or bytes to be allocated.</param>
        /// <param name="binary">Whether allocated data are bytes or chars.</param>
        /// <param name="buffer">Returns the buffer where data can be written to.</param>
        /// <param name="position">Returns the position where data can be written on.</param>
        /// <returns>The number of allocated characters or bytes.</returns>
        /// <remarks>
        /// The buffer may already exist or new one may be created.
        /// Works on the current level of buffering.
        /// </remarks>
        private int AllocateBuffer(int sizeNeeded, bool binary, out System.Array buffer, out int position)
        {
            Debug.Assert(_level != null);

            BufferElement element;
            int           chunk;
            int           kind = binary ? 1 : 0;

            // close binary buffer:
            _level.freeSpace[1 - kind] = 0;

            if (binary)
            {
                _level.containsByteData = true;
            }
            else
            {
                _level.containsCharData = true;
            }

            // no free space for characters found (no buffer exists, the top buffer isn't a character buffer
            // or the top buffer is full character buffer):
            if (_level.freeSpace[kind] == 0)
            {
                // computes the size of buffer to be allocated as min{sizeNeeded,dafaultBufferSize}:
                int size = sizeNeeded;
                if (size < _minBufferSize[kind])
                {
                    size = _minBufferSize[kind];
                    _level.freeSpace[kind] = size - sizeNeeded;
                }
                else
                {
                    _level.freeSpace[kind] = 0; // all space in allocated buffer will be occupied
                }
                // allocates a new buffer element for data:
                element = new BufferElement();
                if (binary)
                {
                    buffer = new byte[size];
                }
                else
                {
                    buffer = new char[size];
                }
                element.data = buffer;
                element.size = sizeNeeded;   //sizeNeeded <= (buffer size)
                _level.buffers.Add(element);

                position = 0;
                chunk    = sizeNeeded;
            }
            else
            // some free space found:
            {
                Debug.Assert(_level.buffers.Count > 0);

                // available space:
                chunk = (_level.freeSpace[kind] < sizeNeeded) ? _level.freeSpace[kind] : sizeNeeded;

                element                 = _level.buffers[_level.buffers.Count - 1];
                buffer                  = element.data;
                position                = element.data.Length - _level.freeSpace[kind];
                element.size           += chunk;
                _level.freeSpace[kind] -= chunk;
            }
            _level.size += chunk;
            return(chunk);
        }
예제 #10
0
파일: Output.cs 프로젝트: dw4dev/Phalanger
		/// <summary>
		/// Gets a buffer where data of requested size and type can be stored. 
		/// </summary>
		/// <param name="sizeNeeded">The number of characters or bytes to be allocated.</param>
		/// <param name="binary">Whether allocated data are bytes or chars.</param>
		/// <param name="buffer">Returns the buffer where data can be written to.</param>
		/// <param name="position">Returns the position where data can be written on.</param>
		/// <returns>The number of allocated characters or bytes.</returns>
		/// <remarks>
		/// The buffer may already exist or new one may be created.
		/// Works on the current level of buffering.
		/// </remarks>
		private int AllocateBuffer(int sizeNeeded, bool binary, out System.Array buffer, out int position)
		{
			Debug.Assert(level != null);

			BufferElement element;
			int chunk;
			int kind = binary ? 1 : 0;

			// close binary buffer:
			level.freeSpace[1 - kind] = 0;

			if (binary) level.containsByteData = true; else level.containsCharData = true;

			// no free space for characters found (no buffer exists, the top buffer isn't a character buffer
			// or the top buffer is full character buffer):
			if (level.freeSpace[kind] == 0)
			{
				// computes the size of buffer to be allocated as min{sizeNeeded,dafaultBufferSize}:
				int size = sizeNeeded;
				if (size < minBufferSize[kind])
				{
					size = minBufferSize[kind];
					level.freeSpace[kind] = size - sizeNeeded;
				}
				else
					level.freeSpace[kind] = 0; // all space in allocated buffer will be occupied

				// allocates a new buffer element for data:
				element = new BufferElement();
				if (binary) buffer = new byte[size]; else buffer = new char[size];
				element.data = buffer;
				element.size = sizeNeeded;   //sizeNeeded <= (buffer size)
				level.buffers.Add(element);

				position = 0;
				chunk = sizeNeeded;

			}
			else
			// some free space found:
			{
				Debug.Assert(level.buffers.Count > 0);

				// available space:
				chunk = (level.freeSpace[kind] < sizeNeeded) ? level.freeSpace[kind] : sizeNeeded;

				element = (BufferElement)level.buffers[level.buffers.Count - 1];
				buffer = element.data;
				position = element.data.Length - level.freeSpace[kind];
				element.size += chunk;
				level.freeSpace[kind] -= chunk;
			}
			level.size += chunk;
			return chunk;
		}
예제 #11
0
파일: Output.cs 프로젝트: jiahao42/weverca
        /// <summary>
        /// Flushes data on current level of buffering to the sinks or to the previous level.
        /// The current level clean up MUST follow this method's call.
        /// </summary>
        internal void InternalFlush()
        {
            Debug.Assert(level != null);

            if (level.filter != null)
            {
                ChunkPosition chunk_position = ChunkPosition.First | ChunkPosition.Middle | ChunkPosition.Last;

                // writes data to the current level of buffering or to sinks depending on the level count:
                if (level.index > 0)
                {
                    // gets data from user's callback:
                    object data = level.filter.Invoke(GetContent(), chunk_position);

                    // store level to allow its restore:
                    LevelElement old_level = level;

                    // temporarily decreases the level of buffering toredirect writes to the lower level:
                    level = (LevelElement)levels[level.index - 1];

                    // checks whether the filtered data are binary at first; if not so, converts them to a string:
                    PhpBytes bin = data as PhpBytes;
                    if (bin != null)
                    {
                        stream.Write(bin.ReadonlyData, 0, bin.Length);
                    }
                    else
                    {
                        this.Write(PHP.Core.Convert.ObjectToString(data));
                    }

                    // restore the level of buffering:
                    level = old_level;
                }
                else
                {
                    // gets data from user's callback:
                    object data = level.filter.Invoke(GetContent(), chunk_position);

                    // checks whether the filtered data are binary at first; if not so, converts them to a string:
                    PhpBytes bin = data as PhpBytes;
                    if (bin != null)
                    {
                        if (bin.Length > 0)
                        {
                            byteSink.Write(bin.ReadonlyData, 0, bin.Length);
                        }
                    }
                    else
                    {
                        charSink.Write(PHP.Core.Convert.ObjectToString(data));
                    }
                }
            }
            else
            {
                if (level.index > 0)
                {
                    // joins levels (data are not copied => the current level MUST be cleaned up after the return from this method):
                    if (level.size > 0)
                    {
                        LevelElement lower_level = (LevelElement)levels[level.index - 1];

                        lower_level.buffers.AddRange(level.buffers);
                        lower_level.size             += level.size;
                        lower_level.freeSpace         = level.freeSpace;                      // free space in the last buffer of the level
                        lower_level.containsByteData |= level.containsByteData;
                        lower_level.containsCharData |= level.containsCharData;
                    }
                }
                else
                {
                    // writes top-level data to sinks:
                    for (int i = 0; i < level.buffers.Count; i++)
                    {
                        BufferElement element = (BufferElement)level.buffers[i];

                        byte[] bytes = element.data as byte[];
                        if (bytes != null)
                        {
                            byteSink.Write(bytes, 0, element.size);
                        }
                        else
                        {
                            charSink.Write((char[])element.data, 0, element.size);
                        }
                    }
                }
            }
        }
 public VisitStatus Visit <TContainer>(Property <TContainer, BufferElement> property, ref TContainer container, ref BufferElement data)
 {
     if (!Category.HasFlag(Category.BufferData))
     {
         return(VisitStatus.Stop);
     }
     if (Read)
     {
         Assert.That(data.FloatValue, Is.EqualTo(Value * (property as IListElementProperty).Index));
     }
     else
     {
         data.FloatValue = Value * (property as IListElementProperty).Index;
     }
     return(VisitStatus.Stop);
 }
 public VisitStatus Visit <TContainer>(Property <TContainer, BufferElement> property, ref TContainer container, ref BufferElement data)
 {
     Assert.That(data.Category, Is.EqualTo(Category.BufferData));
     return(VisitStatus.Stop);
 }
예제 #14
0
        public void GetBufferDataCount(ShaderDataType type, int count)
        {
            var result = new BufferElement(type, "Test").GetCount();

            Assert.Equal(count, result);
        }
예제 #15
0
        public void GetShaderDataTypeSize(ShaderDataType type, int size)
        {
            var result = BufferElement.ShaderDataTypeSize(type);

            Assert.Equal(size, result);
        }
예제 #16
0
        private void UpdatePath(TickItem sender, GameWindow game, FrameEventArgs e)
        {
            _selectedCountry = _countries.RandomSubset(2).ToArray();

            var pathingCities = new[] {
                _selectedCountry?[0].Cities.RandomSubset(1).First(),
                _selectedCountry?[1].Cities.RandomSubset(1).First()
            };

            var connected =
                _selectedCountry[0].BorderCountries.Any(
                    o => o == _selectedCountry[1] || o.BorderCountries.Contains(_selectedCountry[1]));

            if (connected)
            {
                var middleC = _selectedCountry[0].BorderCountries.Contains(_selectedCountry[1])
                                        ? null
                                        : _selectedCountry[0].BorderCountries.FirstOrDefault(
                    o => o.BorderCountries.Contains(_selectedCountry[1]));

                if (_selectedCountry == null)
                {
                    return;
                }

                if (middleC != null)
                {
                    var path = new[] {
                        AStar.FindPath(pathingCities[0], _selectedCountry[0].Outbound[middleC], Distance, Distance),
                        AStar.FindPath(middleC.Outbound[_selectedCountry[0]], middleC.Outbound[_selectedCountry[1]],
                                       Distance, Distance),
                        AStar.FindPath(_selectedCountry[1].Outbound[middleC], pathingCities[1], Distance, Distance)
                    };

                    path[2].FirstPath.PreviousSteps = path[1];
                    path[1].FirstPath.PreviousSteps = path[0];
                    pathingCities = path[2].ToArray();
                    _path         = path[2];
                }
                else
                {
                    var path = new[] {
                        AStar.FindPath(pathingCities[0], _selectedCountry[0].Outbound[_selectedCountry[1]], Distance,
                                       Distance),
                        AStar.FindPath(_selectedCountry[1].Outbound[_selectedCountry[0]], pathingCities[1], Distance,
                                       Distance)
                    };

                    path[1].FirstPath.PreviousSteps = path[0];
                    pathingCities = path[1].ToArray();
                    _path         = path[1];
                }
            }
            else
            {
                var path = new[] {
                    AStar.FindPath(pathingCities[0], _selectedCountry[0].Cities[0], Distance, Distance),
                    new Path <City>(_selectedCountry[1].Cities[0])
                    {
                        PreviousSteps = new Path <City>(_selectedCountry[0].Cities[0])
                    },
                    AStar.FindPath(_selectedCountry[1].Cities[0], pathingCities[1], Distance, Distance)
                };
                path[2].FirstPath.PreviousSteps = path[1];
                path[1].FirstPath.PreviousSteps = path[0];
                pathingCities = path[2].ToArray();
                _path         = path[2];
            }

            _paths = new BufferElement[(pathingCities.Length - 1) * 2];

            for (var i = 0; i < pathingCities.Length - 1; i++)
            {
                var d = (float)((pathingCities[i].Longitude / _scale) + _add.X);
                if (d < -1)
                {
                    d += 2;
                }
                var d2 = (float)((pathingCities[i + 1].Longitude / _scale) + _add.X);
                if (d2 < -1)
                {
                    d2 += 2;
                }
                var color = pathingCities[i].Country == pathingCities[i + 1].Country ||
                            pathingCities[i].Country.BorderCountries.Contains(pathingCities[i + 1].Country)
                                        ? new Vector4(1f, 0f, 0f, 1f)
                                        : new Vector4(0f, 0f, 1f, 1f);

                _paths[i * 2] = new BufferElement(new Vector2(d, (float)((pathingCities[i].Latitude / _scale) + _add.Y)),
                                                  color);
                _paths[(i * 2) + 1] =
                    new BufferElement(new Vector2(d2, (float)((pathingCities[i + 1].Latitude / _scale) + _add.Y)), color);
            }

            PathBuffer?.Dispose();
            PathBuffer = new VertexBuffer <BufferElement>(_paths, () =>
            {
                GL.EnableClientState(ArrayCap.VertexArray);
                GL.EnableClientState(ArrayCap.ColorArray);
                GL.VertexPointer(2, VertexPointerType.Float, BufferElement.SizeInBytes, new IntPtr(0));
                GL.ColorPointer(4, ColorPointerType.Float, BufferElement.SizeInBytes, new IntPtr(Vector2.SizeInBytes));
            });

            _pathText.Text = _path.ToString();
        }