/// <summary>
 /// Constructor for the Vertex3 class, takes float variables for the x y and z positions, as well as a color.
 /// </summary>
 /// <param name="x">The float representation of the Vertex3's x position.</param>
 /// <param name="y">The float representation of the Vertex3's y position.</param>
 /// <param name="z">The float representation of the Vertex3's z position.</param>
 /// <param name="color">The color of this particular Vertex3.</param>
 public Vertex3(float x, float y, float z, Color4 color)
 {
     this.x = x;
     this.y = y;
     this.z = z;
     this.myColor = color;
 }

 public static void DrawRect(float x, float y, float z, float width, float height, int lineWidth, Color4 color)
 {
     GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
     GL.LineWidth(lineWidth);
     FillRect(x, y, z, width, height, color);
     GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BlendState" /> class.
 /// </summary>
 /// <param name="device">The device local.</param>
 /// <param name="description">The description.</param>
 /// <param name="blendFactor">The blend factor.</param>
 /// <param name="mask">The mask.</param>
 private BlendState(GraphicsDevice device, BlendStateDescription description, Color4 blendFactor, int mask) : base(device)
 {
     Description = description;
     BlendFactor = blendFactor;
     MultiSampleMask = mask;
     Initialize(new Direct3D11.BlendState(GraphicsDevice, Description));
 }

 public BasicVec4(Color4 v)
 {
     x = v.R;
     y = v.G;
     z = v.B;
     w = v.A;
 }

 // Main constructor:
 public BooleanIndicator(RenderSet render_set, double x, double y)
     : base(render_set, x, y, 1.0, 1.0, null, Texture.Get("sprite_indicator"))
 {
     State = false;
     _Color = new Color4(Color.SkyBlue);
     _NextLayer = new LayeredSprite(render_set, x, y, 1.0, 1.0, null, Texture.Get ("sprite_indicator_gloss"));
 }

 public override Color4[] GetData(int subresource)
 {
     var data = _subresources[subresource].Data;
     var result = new Color4[data.Length];
     Utilities.Copy(data, result);
     return result;
 }

 public Material()
 {
     Ambient = new Color4(1, 1, 1);
     Diffuse = new Color4(1, 1, 1);
     Specular = new Color4(1, 1, 1);
     SpecularExponent = 0.1f;
 }

 /// <summary>
 /// Initializes with the specified colors.
 /// </summary>
 /// <param name="colors">The colors.</param>
 /// <msdn-id>ee719750</msdn-id>	
 /// <unmanaged>HRESULT IWICPalette::InitializeCustom([In, Buffer] void* pColors,[In] unsigned int cCount)</unmanaged>	
 /// <unmanaged-short>IWICPalette::InitializeCustom</unmanaged-short>	
 public void Initialize(Color4[] colors)
 {
     var rawColors = new Color[colors.Length];
     for (int i = 0; i < rawColors.Length; i++)
         rawColors[i] = (Color)colors[i];
     Initialize(rawColors);
 }

 /// <summary>
 /// 立方体を作成する
 /// </summary>
 /// <param name="_position">中心座標</param>
 /// <param name="_size">1辺の長さ</param>
 /// <param name="_color">表示色</param>
 public Cube(Vector3 _position, float _size, Color4 _color)
 {
     // 各パラメーターを設定
     this.position = _position;
     this.size = _size;
     this.color = _color;
 }

 /// <summary>
 /// 立方体を作成する
 /// </summary>
 /// <param name="_size">1辺の長さ</param>
 /// <param name="_color">表示色</param>
 public Cube(float _size, Color4 _color)
 {
     // 各パラメーターを設定
     this.position = new Vector3();
     this.size = _size;
     this.color = _color;
 }

 /// <summary>
 /// Draws this shape using the given scale and offset.
 /// </summary>
 public void Draw(Render Render, Color4 Color, Vector Offset, double Scale)
 {
     Render.Vertex(Destination.TopLeft * Scale + Offset, Source.TopLeft, Color);
     Render.Vertex(Destination.BottomLeft * Scale + Offset, Source.BottomLeft, Color);
     Render.Vertex(Destination.BottomRight * Scale + Offset, Source.BottomRight, Color);
     Render.Vertex(Destination.TopRight * Scale + Offset, Source.TopRight, Color);
 }

		/// <summary>
		/// Creates instance of EnvLight
		/// </summary>
		public EnvLight ()
		{
			Position	=	Vector3.Zero;
			RadiusInner	=	0;
			RadiusOuter	=	1;
			Intensity	=	new Color4(1,1,1,0);
		}

 public Vertex(Vector4 position, Color4 color, Vector2 textureCoordinate)
 {
     Position = position;
     Color = color;
     TextureCoordinate = textureCoordinate;
     _pad0 = Vector2.Zero; // important to align the vertex to a 16 byte boundary
 }

        /// <summary>
        /// position is top left of box.
        /// </summary>
        /// <param name="position"></param>
        /// <param name="size"></param>
        /// <param name="color"></param>
        public ColorBox(Vector2 position, Vector2 size, Color4 color)
        {
            this.position = position;
            this.size = size;
            model = Matrix4.CreateTranslation(position.X, position.Y, 0);
            Color = color;

            float[] vertices = new float[]
            {
                0, 0,
                0, size.Y,
                size.X, 0,
                size.X, size.Y
            };

            uint[] indices = new uint[]
            {
                0, 1, 2, 3
            };

            VBO vert = new VBO(), ind = new VBO();
            vert.SetData(ref vertices, BufferUsageHint.StaticDraw);
            ind.SetData(ref indices, BufferUsageHint.StaticDraw);

            bufSet = new BufferSet();
            bufSet.VertexBuffer = vert;
            bufSet.IndexBuffer = ind;
            bufSet.VertexSize = 2;
            bufSet.DrawMode = BeginMode.TriangleStrip;
            bufSet.SetDrawState(DrawStates.Vertex);
        }

 public Pixel(Color4 color)
     : this()
 {
     RedF = color.R;
     GreenF = color.G;
     BlueF = color.B;
 }

 public TextSprite(Loc2D loc, string text, Color4 color)
 {
     EffectLoc = loc;
     Text = text;
     ActionDone = false;
     Color = color;
 }

        /// <summary>
        /// The base DrawTexture function.
        /// </summary>
        /// <param name="texture">The texture to draw</param>
        /// <param name="destRectangle">The destination rectangle, in pixel space, where the texture is drawn</param>
        /// <param name="sourceRectangle">The source within the texture, values must be between [0-1]</param>
        /// <param name="color">The color to be applied</param>
        /// <param name="rotation">The rotation, in degrees to be applied</param>
        /// <param name="origin">The origin of the rotation, this value is in pixel space referenced from the top left of destRectangle</param>
        public static void DrawTexture(Texture2D texture, RectangleF destRectangle, RectangleF sourceRectangle, Color4 color, float rotation, Vector2 origin)
        {
            RectangleF atlasRect = texture.TextureCoordRect;
            RectangleF sourceInAtlasCoords = new RectangleF(atlasRect.Left + atlasRect.Width * sourceRectangle.Left, atlasRect.Top + atlasRect.Height * sourceRectangle.Top,
                atlasRect.Width * sourceRectangle.Width, atlasRect.Height * sourceRectangle.Height);

            GL.Enable(EnableCap.Texture2D);
            GL.PushMatrix();
            GL.Translate(destRectangle.Left + origin.X, destRectangle.Top + origin.Y, 0);
            GL.Rotate(rotation, 0.0f, 0.0f, 1.0f);
            GL.Translate(-origin.X, -origin.Y, 0);
            GL.BindTexture(TextureTarget.Texture2D, texture.ID);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);

            float width = destRectangle.Width;
            float height = destRectangle.Height;
            GL.Color4(color);
            GL.Begin(PrimitiveType.Quads);
            GL.TexCoord2(sourceInAtlasCoords.Left, sourceInAtlasCoords.Top);
            GL.Vertex2(0.0f, 0.0f);

            GL.TexCoord2(sourceInAtlasCoords.Right, sourceInAtlasCoords.Top);
            GL.Vertex2(width, 0.0f);

            GL.TexCoord2(sourceInAtlasCoords.Right, sourceInAtlasCoords.Bottom);
            GL.Vertex2(width, height);

            GL.TexCoord2(sourceInAtlasCoords.Left, sourceInAtlasCoords.Bottom);
            GL.Vertex2(0.0f, height);
            GL.End();
            GL.PopMatrix();
            GL.Disable(EnableCap.Texture2D);
        }

 /// <summary>
 /// 粒子を作成する
 /// </summary>
 /// <param name="_x">中心座標</param>
 /// <param name="_d">直径</param>
 /// <param name="_color">表示色</param>
 public OutputParticle(Vector3 _x, float _d, Color4 _color)
 {
     // 各パラメーターを設定
     this.X = _x;
     this.d = _d;
     this.color = _color;
 }

        private RadialGradientBrush CreateRadialGradientBrush(DeviceContext context, float width, float height, Color4 color1, Color4 color2, float color1Position, float color2Position)
        {

            GradientStop[] stops = new GradientStop[2];
            //stops[0] = new GradientStop() { Color = new Color4(0.85f, 0, 0, 1.0f), Position = 0.0f };
            //stops[1] = new GradientStop() { Color = new Color4(0.22f, 0, 0, 1.0f), Position = 1.0f };
            stops[0] = new GradientStop() { Color = color1, Position = color1Position };
            stops[1] = new GradientStop() { Color = color2, Position = color2Position };


            GradientStopCollection gsc = new GradientStopCollection(context, stops, ExtendMode.Clamp);

            RadialGradientBrush brush = new RadialGradientBrush(
                context,
                new RadialGradientBrushProperties()
                {
                    RadiusX = width / 1.3f,
                    RadiusY = height / 1.3f,
                    Center = new Vector2(width / 2.0f, height / 2.0f),
                    GradientOriginOffset = new Vector2(0, 0)
                },
                gsc);


            return brush;
        }

        private static ColorRamp FromValues(string name, params OpenTK.Graphics.Color4[] colors)
        {
            var sizeX = 2;
            var sizeY = 1;
            var data = new Color4[sizeY, sizeX];

            //var dX = sizeX / (float)colors.Length;
            //var dY = sizeY / (float)colors.Length;
            //		var colorIndex = 0;

            for (int i = 0; i < sizeY; i++)
            {
                for (int j = 0; j < sizeX; j++)
                {
                    //var t = dX * (j / colors.Length);
                    var cindex = j % colors.Length;
                    data[i, j] = colors[cindex];
                }
            }

            var texture = new DataTexture<Color4>
            {
                Name = "color-ramp-" + name,
                InternalFormat = PixelInternalFormat.Rgb,
                Data2D = data,
                Params = new TextureBase.Parameters
                {
                    GenerateMipmap = false,
                    MinFilter = TextureMinFilter.Linear,
                    MagFilter = TextureMagFilter.Linear
                }};

              return new ColorRamp(name, texture);
        }