public BlurComponent(Device graphics, int size)
        {
            _graphics = graphics;

            Dims = size;
            Format = Format.A8R8G8B8;

            _sampleOffsetsHoriz = new Vector4D[SampleCount];
            _sampleOffsetsVert = new Vector4D[SampleCount];

            _sampleWeightsHoriz = new float[SampleCount];
            _sampleWeightsVert = new float[SampleCount];

            int width = Dims - 5;
            int height = Dims - 5;

            SetBlurEffectParameters(1.0f / width, 0, ref _sampleOffsetsHoriz, ref _sampleWeightsHoriz);
            SetBlurEffectParameters(0, 1.0f / height, ref _sampleOffsetsVert, ref _sampleWeightsVert);

            _effect = new GaussianBlurEffect(_graphics);

            OutputTexture = new Texture(_graphics, Dims, Dims, 1, Usage.RenderTarget, Format, Pool.Default);
            _intermediateTexture = new Texture(_graphics, Dims, Dims, 1, Usage.RenderTarget, Format, Pool.Default);

            _sprite = new Sprite(_graphics);
        }

 /// <summary>Initializes a new instance of the <see cref="DisplayMode"/> class.</summary>
 /// <param name="pixelFormat">The pixel format.</param>
 /// <param name="width">The width.</param>
 /// <param name="height">The height.</param>
 /// <param name="refreshRate">The refresh rate.</param>
 public DisplayMode(Format pixelFormat, int width, int height, Rational refreshRate)
 {
     this.pixelFormat = pixelFormat;
     this.width = width;
     this.height = height;
     this.refreshRate = refreshRate;
 }

        public D3DDevice(IntPtr windowPtr, bool bWindowed, long Width, long Height)
        {
            m_bWindowed = bWindowed;
            m_Format = Find16BitMode();

            PresentParameters presentParameters		 = new PresentParameters();
            presentParameters.Windowed				 = m_bWindowed;
            presentParameters.SwapEffect			 = SwapEffect.Discard;
            presentParameters.BackBufferCount		 = 1;
            presentParameters.PresentationInterval	 = PresentInterval.Immediate;
            presentParameters.AutoDepthStencilFormat = DepthFormat.D16;
            presentParameters.EnableAutoDepthStencil = true;

            if(!bWindowed)
            {
                presentParameters.BackBufferFormat	= m_Format;
                presentParameters.BackBufferWidth	= (int)Width;
                presentParameters.BackBufferHeight	= (int)Height;
            }
            else
            {
                presentParameters.BackBufferFormat	= Format.Unknown;
                presentParameters.BackBufferWidth	= (int)Width;
                presentParameters.BackBufferHeight	= (int)Height;
            }

            m_D3DDevice = new Microsoft.DirectX.Direct3D.Device(0,
                DeviceType.Hardware, windowPtr,
                CreateFlags.SoftwareVertexProcessing, presentParameters);
        }

        internal void Clear()
        {
            m_deviceContext.ClearState();

            m_inputLayout = null;
            m_primitiveTopology = PrimitiveTopology.Undefined;
            m_indexBufferRef = null;
            m_indexBufferFormat = Format.Unknown;
            m_indexBufferOffset = 0;
            for (int i = 0; i < m_vertexBuffers.Length; i++)
                m_vertexBuffers[i] = null;
            for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
                m_vertexBuffersStrides[i] = 0;

            m_blendState = null;
            m_stencilRef = 0;
            m_depthStencilState = null;
            m_rtvsCount = 0;
            for (int i = 0; i < m_rtvs.Length; i++)
                m_rtvs[i] = null;
            m_dsv = null;

            m_rasterizerState = null;
            m_scissorLeftTop = new Vector2I(-1, -1);
            m_scissorRightBottom = new Vector2I(-1, -1);
            m_viewport = default(RawViewportF);

            m_targetBuffer = null;
            m_targetOffsets = 0;

            m_statistics.ClearStates++;
        }

 /// <summary>
 /// Gets the number of alpha channel bits.
 /// </summary>
 public static int GetAlphaChannelBits(Format format)
 {
   switch (format)
   {
     case Format.R8G8B8:
       return 0;
     case Format.A8R8G8B8:
       return 8;
     case Format.X8R8G8B8:
       return 0;
     case Format.R5G6B5:
       return 0;
     case Format.X1R5G5B5:
       return 0;
     case Format.A1R5G5B5:
       return 1;
     case Format.A4R4G4B4:
       return 4;
     case Format.R3G3B2:
       return 0;
     case Format.A8R3G3B2:
       return 8;
     case Format.X4R4G4B4:
       return 0;
     case Format.A2B10G10R10:
       return 2;
     case Format.A2R10G10B10:
       return 2;
     default:
       return 0;
   }
 }

        public void EvaluateFormat(object current, Format format, ref bool handled, IOutput output, FormatDetails formatDetails)
        {
            if (format != null && format.HasNested) return;
            var formatText = format != null ? format.Text : "";
            TimeSpan fromTime;
            if (current is TimeSpan)
            {
                fromTime = (TimeSpan)current;
            }
            else if (current is DateTime && formatText.StartsWith("timestring"))
            {
                formatText = formatText.Substring(10);
                fromTime = DateTime.Now.Subtract((DateTime)current);
            }
            else
            {
                return;
            }
            var timeTextInfo = GetTimeTextInfo(formatDetails.Provider);
            if (timeTextInfo == null)
            {
                return;
            }
            var formattingOptions = TimeSpanFormatOptionsConverter.Parse(formatText);
            var timeString = TimeSpanUtility.ToTimeString(fromTime, formattingOptions, timeTextInfo);
            output.Write(timeString, formatDetails);
            handled = true;

        }

 /// <summary>
 /// Inflate the data with the given format stored in a buffer
 /// </summary>
 /// <param name="buffer">A view with the encoded data</param>
 /// <param name="format">An inflated format object</param>
 /// <returns>Return null, an ArrayList or a single value (ulong, long, float, Token or string)</returns>
 internal static object Inflate(BufferView buffer, Format format)
 {
     ArrayList data = new ArrayList();
     if (InflateData.ReadElement(buffer, data, format.Root).Length != 0)
         throw new ArgumentException("Unable to read data in the given format");
     return data.Count == 0 ? null : (data.Count == 1 ? data[0] : data);
 }

		public FormattingInfo(FormattingInfo parent, FormatDetails formatDetails, Format format, object currentValue)
		{
			this.Parent = parent;
			CurrentValue = currentValue;
			Format = format;
			FormatDetails = formatDetails;
		}

 public static byte[] Decompress(int width, int height, byte[] source, Format format)
 {
     using (var strm = new MemoryStream(source))
     {
         return Decompress(width, height, new BinaryReader(strm), format);
     }
 }

        public Consumer(string host, string groupName, string instanceId, Format format, string offset = "smallest")
        {
            this.host = host;
            this.groupName = groupName;
            this.instanceId = instanceId;
            this.format = format;

            var contentType = "application/vnd.kafka.v1+json";
            var data = new Dictionary<string, string>
            {
                {"name", instanceId},
                {"format", format.ToString().ToLower()},
                {"auto.offset.reset", offset}
            };
            try
            {
                var responseString = WebRequestHelper.Post(host, $"consumers/{groupName}", JsonConvert.SerializeObject(data),
                    contentType);
                dynamic response = JsonConvert.DeserializeObject<dynamic>(responseString);
                this.instanceId = response.instance_id.ToObject<string>();
                baseUri = response.base_uri.ToObject<string>();
            }
            catch (Exception e)
            {
                // it means, that consumer with this name already exists
                log.Warn(e.Message);
                baseUri = $"{host}/consumers/{groupName}/instances/{instanceId}";
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="VertexElement" /> struct.
 /// </summary>
 /// <param name="semanticName">Name of the semantic.</param>
 /// <param name="semanticIndex">Index of the semantic.</param>
 /// <param name="format">The format.</param>
 /// <param name="alignedByteOffset">The aligned byte offset.</param>
 public VertexElementAttribute(string semanticName, int semanticIndex, Format format, int alignedByteOffset = VertexElement.AppendAligned)
 {
     this.semanticName = semanticName;
     this.semanticIndex = semanticIndex;
     this.format = format;
     this.alignedByteOffset = alignedByteOffset;
 }

        public static string GetContentType(Format formats)
        {
            switch (formats)
            {
                case Format.Soap11:
                case Format.Soap12:
                case Format.Xml:
                    return Xml;

                case Format.Json:
                    return Json;

                case Format.Jsv:
                    return JsvText;

                case Format.Csv:
                    return Csv;

                case Format.ProtoBuf:
                    return ProtoBuf;

                case Format.MsgPack:
                    return MsgPack;

                default:
                    return null;
            }
        }

    void OnGUI()
    {
        GUILayout.BeginHorizontal();
            GUI.enabled = m_Format != Format.Pretty;
            if( GUILayout.Button ("PrettyFormat") )
            {
                m_Format = Format.Pretty;
            }

            GUI.enabled = m_Format != Format.Plain;
            if( GUILayout.Button ("Plain Format") )
            {
                m_Format = Format.Plain;
            }
        GUILayout.EndHorizontal();

        GUI.enabled = true;
        if( GUILayout.Button("Serialize", GUILayout.Height (100)) )
        {
            _TestSerialInfo();
        }

        m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos, GUILayout.Width (Screen.width-200));
        if( m_str1.Length > 0)
        {
            GUILayout.TextArea(m_str1);
        }
        GUILayout.EndScrollView();
    }

 public static int CompressedImageSize(Format format, int width, int height, int depth, int byteAlignment)
 {
     int rowPitch, slicePitch, totalSize;
     switch (format)
     {
         case Format.CompressedRgbaS3tcDxt1Ext:
         case Format.CompressedSrgbAlphaS3tcDxt1Ext:
         case Format.CompressedRedRgtc1: // bc4
         case Format.CompressedSignedRedRgtc1:
             TextureHelper.GetInfoForSetDataCompressed(4, width, height, depth, byteAlignment, out rowPitch, out slicePitch, out totalSize);
             return totalSize;
         case Format.CompressedRgbaS3tcDxt3Ext:
         case Format.CompressedSrgbAlphaS3tcDxt3Ext:
         case Format.CompressedRgbaS3tcDxt5Ext:
         case Format.CompressedSrgbAlphaS3tcDxt5Ext:
         case Format.CompressedRgRgtc2:
         case Format.CompressedSignedRgRgtc2:
         case Format.CompressedRgbaBptcUf:
         case Format.CompressedRgbaBptcSf:
         case Format.CompressedRgbaBptc:
         case Format.CompressedSrgbAlphaBptc:
             TextureHelper.GetInfoForSetDataCompressed(8, width, height, depth, byteAlignment, out rowPitch, out slicePitch, out totalSize);
             return totalSize;
         default:
             throw new InvalidOperationException(string.Format("Format '{0}' is not a known compressed format", format));
     }
 }

		public SqlUserDefinedTypeAttribute (Format f)
		{
			Format = f;
			IsByteOrdered = false;
			IsFixedLength = false;
			MaxByteSize = MaxByteSizeValue;
		}

        /// <summary>
        /// Creates a new graphics resource.
        /// </summary>
        /// <param name="device">The graphics device to use.</param>
        /// <param name="dimensions">The resource dimensions.</param>
        /// <param name="format">The resource's DXGI format.</param>
        /// <param name="renderTargetView">Whether to bind as RTV.</param>
        /// <param name="shaderResourceView">Whether to bind as SRV.</param>
        /// <param name="hasMipMaps">Whether to enable mip-maps for this texture.</param>
        public GraphicsResource(Device device, Size dimensions, Format format, Boolean renderTargetView = true, Boolean shaderResourceView = true, Boolean hasMipMaps = false)
        {
            if ((!renderTargetView) && (!shaderResourceView))
                throw new ArgumentException("The requested resource cannot be bound at all to the pipeline.");

            if ((hasMipMaps) && ((!renderTargetView) || (!shaderResourceView)))
                throw new ArgumentException("A resource with mipmaps must be bound as both input and output.");

            BindFlags bindFlags = (renderTargetView ? BindFlags.RenderTarget : 0) | (shaderResourceView ? BindFlags.ShaderResource : 0);
            ResourceOptionFlags optionFlags = (hasMipMaps ? ResourceOptionFlags.GenerateMipMaps : 0);
            int mipLevels = (hasMipMaps ? MipLevels(dimensions) : 1);

            Resource = new Texture2D(device, new Texture2DDescription()
            {
                Format = format,
                BindFlags = bindFlags,
                Width = dimensions.Width,
                Height = dimensions.Height,

                ArraySize = 1,
                MipLevels = mipLevels,
                OptionFlags = optionFlags,
                Usage = ResourceUsage.Default,
                CpuAccessFlags = CpuAccessFlags.None,
                SampleDescription = new SampleDescription(1, 0),
            });

            RTV = (  renderTargetView ?   new RenderTargetView(device, Resource) : null);
            SRV = (shaderResourceView ? new ShaderResourceView(device, Resource) : null);
        }

        //-------------------------------------------------------------------
        // Constructor
        //-------------------------------------------------------------------
        public DrawDevice()
        {
            m_hwnd = IntPtr.Zero;
            m_pDevice = null;
            m_pSwapChain = null;

            m_d3dpp = null;
            m_Data = IntPtr.Zero;

            m_format = Format.X8R8G8B8;
            m_width = 0;
            m_height = 0;
            m_lDefaultStride = 0;
            m_PixelAR.Denominator = m_PixelAR.Numerator = 1;
            m_rcDest = Rectangle.Empty;

            VideoFormatDefs = new VideoFormatGUID[] {
                new VideoFormatGUID(MFMediaType.RGB32, TransformImage_RGB32, ARGB32_To_RGB32),
                new VideoFormatGUID(MFMediaType.RGB24, TransformImage_RGB24, ARGB32_To_RGB24),
                new VideoFormatGUID(MFMediaType.YUY2, TransformImage_YUY2, ARGB32_To_YUY2),
                new VideoFormatGUID(MFMediaType.NV12, TransformImage_NV12, ARGB32_To_NV12)
            };

            m_convertFn = null;
            m_bmpconvertFn = null;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////
        /// Static and helper functions
        ////////////////////////////////////////////////////////////////////////////////////////////////
        public static bool Import(tk2dTileMap tileMap, Format format)
        {
            var importer = new Importer();

            string ext = "";
            switch (format)
            {
                case Format.TMX:
                    if (!importer.CheckZlib()) return false;
                    ext = "tmx";
                break;
            }

            string path = EditorUtility.OpenFilePanel("Import tilemap", "", ext);
            if (path.Length == 0)
                return false;

            string message = "";
            switch (format)
            {
            case Format.TMX: message = importer.ImportTMX(path); break;
            }

            if (message.Length != 0)
            {
                EditorUtility.DisplayDialog("Tilemap failed to import", message, "Ok");
                return false;
            }

            importer.PopulateTilemap(tileMap);
            return true;
        }

		public void SetIndexBuffer(Buffer indexBuffer, Format format, int offset)
		{
            DiagnosticUtilities.RaiseEvent(this, SettingIndexBuffer, DiagnosticUtilities.GetID(indexBuffer), format, offset);
			if (format != Format.R16_UInt && format != Format.R32_UInt)
				throw new ArgumentOutOfRangeException("format");
			_indexBufferBinding = new IndexBufferBinding(indexBuffer, format, offset);
		}

 public void Init(
     string name,
     int width,
     int height,
     Format resourceFormat,
     Format srvFormat,
     BindFlags bindFlags,
     int samplesCount,
     int samplesQuality,
     ResourceOptionFlags roFlags,
     ResourceUsage ru,
     int mipmapLevels,
     CpuAccessFlags cpuAccessFlags)
 {
     m_name = name;
     m_size = new Vector2I(width, height);
     m_resourceFormat = resourceFormat;
     m_srvFormat = srvFormat;
     m_bindFlags = bindFlags;
     m_samplesCount = samplesCount;
     m_samplesQuality = samplesQuality;
     m_roFlags = roFlags;
     m_resourceUsage = ru;
     m_mipmapLevels = mipmapLevels;
     m_cpuAccessFlags = cpuAccessFlags;
 }