public static void Initilize(GraphicsDevice gd)
 {
     ConstructCube();
     vBuffer = new VertexBuffer(gd, VertexPositionNormalTexture.VertexDeclaration, 36, BufferUsage.WriteOnly);
     vBuffer.SetData(verts);
     gd.SetVertexBuffer(vBuffer);
     ib = new IndexBuffer(gd, IndexElementSize.SixteenBits, 14, BufferUsage.WriteOnly);
     ib.SetData(new short[14]
     {
         0,
         1,
         2,
         3,
         4,
         5,
         6,
         7,
         8,
         9,
         10,
         11,
         12,
         13
     });
     gd.Indices = ib;
     wireframeRaster = new RasterizerState();
     wireframeRaster.FillMode = FillMode.WireFrame;
     wireframeRaster.CullMode = CullMode.None;
     wireframeEfect = new BasicEffect(gd);
     wireframeEfect.Projection = Matrix.CreatePerspectiveFieldOfView(0.7853982f,
         wireframeEfect.GraphicsDevice.Viewport.AspectRatio, 0.01f, 3000f);
 }

    public Sphere(float Radius, GraphicsDevice graphics, Texture2D tex, Texture2D prograde, Texture2D retrograde,
        Texture2D maneuverPrograde, Texture2D targetPrograde, Texture2D targetRetrograde)
    {
        this.prograde = new Bilboard (prograde, Matrix.CreateScale (1.0f));
        this.retrograde = new Bilboard (retrograde, Matrix.CreateScale (1.0f));
        this.maneuverPrograde = new Bilboard (maneuverPrograde, Matrix.CreateScale (1.0f));
        this.targetPrograde = new Bilboard (targetPrograde, Matrix.CreateScale (1.0f));
        this.targetRetrograde = new Bilboard (targetRetrograde, Matrix.CreateScale (1.0f));

        texture = tex;
        radius = Radius;
        graphicd = graphics;
        effect = new BasicEffect(graphicd);

        nvertices = res * res; // 90 vertices in a circle, 90 circles in a sphere
        nindices = res * res * 6;
        vbuffer = new VertexBuffer(graphics, typeof(VertexPositionNormalTexture), nvertices, BufferUsage.WriteOnly);
        ibuffer = new IndexBuffer(graphics, IndexElementSize.SixteenBits, nindices, BufferUsage.WriteOnly);
        createspherevertices();
        createindices();
        vbuffer.SetData<VertexPositionNormalTexture>(vertices);
        ibuffer.SetData<short>(indices);
        effect.TextureEnabled = true;
        effect.LightingEnabled = true;

        rotQuat = Quaternion.Identity;
    }

        public static Model FromScene(Scene scene, Device device)
        {
            VertexDeclaration vertexDeclaration = new VertexDeclaration(device,
                VertexPositionNormalTexture.VertexElements);
            Model result = new Model(scene, device, vertexDeclaration);
            foreach (Mesh mesh in scene.Meshes)
            {
                VertexBuffer vertexBuffer = new VertexBuffer(device,
                    mesh.Positions.Count * VertexPositionNormalTexture.SizeInBytes,
                    Usage.WriteOnly, VertexFormat.None, Pool.Default);
                DataStream vertexDataStream = vertexBuffer.Lock(0,
                    mesh.Positions.Count * VertexPositionNormalTexture.SizeInBytes,
                    LockFlags.None);
                VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[mesh.Positions.Count];
                for (int i = 0; i < vertices.Length; ++i)
                    vertices[i] = new VertexPositionNormalTexture(mesh.Positions[i], (mesh.Normals.Count > i) ? mesh.Normals[i] : Vector3D.Zero, Point2D.Zero);
                vertexDataStream.WriteRange(vertices);
                vertexBuffer.Unlock();

                IndexBuffer indexBuffer = new IndexBuffer(device, mesh.Indices.Count * sizeof(int),
                    Usage.WriteOnly, Pool.Default, false);
                DataStream indexDataStream = indexBuffer.Lock(0, mesh.Indices.Count * sizeof(int), LockFlags.None);
                indexDataStream.WriteRange(mesh.Indices.ToArray());
                indexBuffer.Unlock();

                ModelMesh modelMesh = new ModelMesh(mesh, device, vertexBuffer,
                    mesh.Positions.Count, indexBuffer, mesh.PrimitiveCount,
                    Matrix3D.Identity, mesh.Material);
                result.Meshes.Add(modelMesh);
            }
            return result;
        }

			public void Reload()
			{
				Ovr.DistortionMesh meshData = this.main.VRHmd.CreateDistortionMesh(this.eye, this.fov, this.main.VRHmd.GetDesc().DistortionCaps).Value;
				Point textureSize = this.main.ScreenSize;
				Ovr.Vector2f[] scaleAndOffset = this.main.VRHmd.GetRenderScaleAndOffset(this.fov, new Ovr.Sizei(textureSize.X, textureSize.Y), new Ovr.Recti { Size = { w = textureSize.X, h = textureSize.Y } });
				this.uvScale = new Vector2(scaleAndOffset[0].x, scaleAndOffset[0].y);
				this.uvOffset = new Vector2(scaleAndOffset[1].x, scaleAndOffset[1].y);
				Vertex[] vertices = new Vertex[meshData.VertexCount];
				for (int i = 0; i < meshData.VertexCount; i++)
				{
					Ovr.DistortionVertex v = meshData.pVertexData[i];
					vertices[i].ScreenPosNDC = new Vector2(v.ScreenPosNDC.x, v.ScreenPosNDC.y);
					vertices[i].TimeWarpFactor = v.TimeWarpFactor;
					vertices[i].VignetteFactor = v.VignetteFactor;
					vertices[i].TanEyeAnglesR = new Vector2(v.TanEyeAnglesR.x, v.TanEyeAnglesR.y);
					vertices[i].TanEyeAnglesG = new Vector2(v.TanEyeAnglesG.x, v.TanEyeAnglesG.y);
					vertices[i].TanEyeAnglesB = new Vector2(v.TanEyeAnglesB.x, v.TanEyeAnglesB.y);
				}

				this.vb = new VertexBuffer(this.main.GraphicsDevice, typeof(Vertex), (int)meshData.VertexCount, BufferUsage.WriteOnly);
				this.vb.SetData<Vertex>(vertices);

				this.ib = new IndexBuffer(this.main.GraphicsDevice, IndexElementSize.SixteenBits, (int)meshData.IndexCount, BufferUsage.WriteOnly);
				this.ib.SetData<short>(meshData.pIndexData);
			}

        public TextureStrip(GraphicsDevice device,Texture2D tex)
        {
            worldMatrix = Matrix.Identity;
            Indices = new int[4];
            effect = new BasicEffect(device);
            float aspectRatio = (float)device.Viewport.Width /
            device.Viewport.Height;
            CamX = 0.0f;
            CamY = 2.0f;
            CamZ = 2.0f;
            effect.View = Matrix.CreateLookAt(new Vector3(CamX, CamY, CamZ),Vector3.Zero, Vector3.Up);
            effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10.0f);
            effect.VertexColorEnabled = false;
            textura = tex;
            effect.Texture = this.textura;
            effect.TextureEnabled = true;

            CreateVertices();

            Indices[0]=0;
            Indices[1]=1;
            Indices[2]=2;
            Indices[3]=3;

            effect.LightingEnabled = true;
            effect.DirectionalLight0.DiffuseColor = new Vector3(1, 1, 1);
            effect.DirectionalLight0.Direction = new Vector3(0, -1, 0);
            effect.DirectionalLight0.SpecularColor = new Vector3(0, 0, 0);

            vertexBuffer1 = new VertexBuffer(device, typeof(VertexPositionNormalTexture), vertices.Length, BufferUsage.None);
            vertexBuffer1.SetData<VertexPositionNormalTexture>(vertices);

            indexBuffer1 = new IndexBuffer(device, typeof(int), Indices.Length, BufferUsage.None);
            indexBuffer1.SetData<int>(Indices);
        }

		public Batcher( GraphicsDevice graphicsDevice )
		{
			Assert.isTrue( graphicsDevice != null );

			this.graphicsDevice = graphicsDevice;

			_vertexInfo = new VertexPositionColorTexture4[MAX_SPRITES];
			_textureInfo = new Texture2D[MAX_SPRITES];
			_vertexBuffer = new DynamicVertexBuffer( graphicsDevice, typeof( VertexPositionColorTexture ), MAX_VERTICES, BufferUsage.WriteOnly );
			_indexBuffer = new IndexBuffer( graphicsDevice, IndexElementSize.SixteenBits, MAX_INDICES, BufferUsage.WriteOnly );
			_indexBuffer.SetData( _indexData );

			_spriteEffect = new SpriteEffect();
			_spriteEffectPass = _spriteEffect.CurrentTechnique.Passes[0];

			_projectionMatrix = new Matrix(
				0f, //(float)( 2.0 / (double)viewport.Width ) is the actual value we will use
				0.0f,
				0.0f,
				0.0f,
				0.0f,
				0f, //(float)( -2.0 / (double)viewport.Height ) is the actual value we will use
				0.0f,
				0.0f,
				0.0f,
				0.0f,
				1.0f,
				0.0f,
				-1.0f,
				1.0f,
				0.0f,
				1.0f
			);
		}

 /// <summary>
 /// Constructor of IndexBufferObject class
 /// </summary>
 /// <param name="device">Graphics device</param>
 /// <param name="type">Type of buffer to use</param>
 /// <param name="buffer">Underlying index buffer</param>
 internal IndexBufferObject(GraphicsDevice device, BufferType type, IndexBuffer buffer)
 {
     _device = device;
     _bufferType = type;
     _elementSize = buffer.IndexElementSize;
     CreateWrapper(buffer);
 }

 public void InitializePrimitive(GraphicsDevice graphicsDevice)
 {
     VertexBuffer = new VertexBuffer(graphicsDevice, typeof(Vertex), Vertices.Count, BufferUsage.None);
     VertexBuffer.SetData(Vertices.ToArray());
     IndexBuffer = new IndexBuffer(graphicsDevice, typeof(int), Indices.Count, BufferUsage.None);
     IndexBuffer.SetData(Indices.ToArray());
 }

        public HeightMappedTerrain(Texture2D heightmap, float cellsize, float height, Texture2D basetex, float textile, Vector3 lightdir, GraphicsDevice device, ContentManager content)
        {
            baseTexture = basetex;
            textureTiling = textile;
            lightDirection = lightdir;

            heightMap = heightmap;
            width = heightmap.Width;
            length = heightMap.Height;

            cellSize = cellsize;
            this.height = height;
            GraphicsDevice = device;

            effect = content.Load<Effect>("TerrainEffect");
            nVertices = width * length;
            nIndices = (width - 1) * (length - 1) * 6;

            vertexBuffer = new VertexBuffer(device, typeof(VertexPositionNormalTexture), nVertices, BufferUsage.WriteOnly);
            indexBuffer = new IndexBuffer(device, IndexElementSize.ThirtyTwoBits, nIndices, BufferUsage.WriteOnly);

            extractHeightData();
            createVertexData();
            createIndexData();
            createNormalData();

            vertexBuffer.SetData<VertexPositionNormalTexture>(vertices);
            indexBuffer.SetData<int>(indices);
        }

        protected override void LoadContent()
        {
            base.LoadContent();

             effect = new BasicEffect(GraphicsDevice, null);
             effect.VertexColorEnabled = true;
             effect.Projection = Matrix.CreateOrthographicOffCenter(0, GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, 0, 0, 1);

             vertexDeclaration = new VertexDeclaration(GraphicsDevice, VertexPositionColor.VertexElements);

             Color c = Color.Red;

             for (int x = 0; x <= Constants.WIN_X; x += xMax)
             {
            listVertices.Add(new VertexPositionColor(new Vector3(x, Constants.WIN_Y - y, 0), Color.Red));
            listVertices.Add(new VertexPositionColor(new Vector3(x, Constants.WIN_Y, 0), Color.Blue));
             }

             for (int i = 0; i < listVertices.Count - 1; i+=2)
             {
            listIndices.Add((short)(i));
            listIndices.Add((short)(3 + i));
            listIndices.Add((short)(1 + i));
            listIndices.Add((short)(i));
            listIndices.Add((short)(2 + i));
            listIndices.Add((short)(3 + i));
             }

             buffVertex = new VertexBuffer(GraphicsDevice, VertexPositionColor.SizeInBytes * listVertices.Count, BufferUsage.WriteOnly);
             buffVertex.SetData<VertexPositionColor>(listVertices.ToArray());

             buffIndex = new IndexBuffer(GraphicsDevice, typeof(short), listIndices.Count, BufferUsage.WriteOnly);
             buffIndex.SetData<short>(listIndices.ToArray());
        }

        /// <summary>
        /// Performs further custom initialization for this instance.
        /// </summary>
        protected override void Initialize()
        {
            base.Initialize();

            VertexPositionColor[] vertices = new VertexPositionColor[3];
            vertices[0].Position = new Vector3(-0.5f, -0.5f, 0f);
            vertices[0].Color = Color.Red;

            vertices[1].Position = new Vector3(0f, 0.5f, 0f);
            vertices[1].Color = Color.Green;

            vertices[2].Position = new Vector3(0.5f, -0.5f, 0f);
            vertices[2].Color = Color.Yellow;

            var vertexBuffer = new VertexBuffer(VertexPositionColor.VertexFormat);
            vertexBuffer.SetData(vertices, 3);
            
            ushort[] indices = new ushort[3];
            indices[0] = 0;
            indices[1] = 1;
            indices[2] = 2;

            var indexBuffer = new IndexBuffer(indices);

            this.mesh = new Mesh(0, vertices.Length, 0, 1, vertexBuffer, indexBuffer, PrimitiveType.TriangleList);
        }

        /// <inheritdoc/>
        public override void Attach(IndexBuffer ibuffer)
        {
            Contract.Require(ibuffer, "ibuffer");
            Contract.EnsureNot(HasIndices, UltravioletStrings.GeometryStreamAlreadyHasIndices);
            Contract.EnsureNotDisposed(this, Disposed);

            Ultraviolet.ValidateResource(ibuffer);

            var sdlIndexBuffer = (OpenGLIndexBuffer)ibuffer;
            var sdlIndexBufferName = sdlIndexBuffer.OpenGLName;

            this.ibuffer = sdlIndexBuffer;

            if (IsUsingVertexArrayObject)
            {
                using (OpenGLState.ScopedBindVertexArrayObject(vao, 0, 0, true))
                {
                    gl.BindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, sdlIndexBufferName);
                    gl.ThrowIfError();
                }
            }

            this.glElementArrayBufferBinding = sdlIndexBufferName;
            this.indexBufferElementType      = ibuffer.IndexElementType;
        }

        public Terrain(Texture2D heightMap,
            Effect effect,
            float cellSize,
            int maxHeight,
            GraphicsDevice device)
        {
            this.HeightMap = heightMap;
            this.Width = heightMap.Width;
            this.Height = maxHeight;
            this.Length = heightMap.Height;
            this.CellSize = cellSize;

            this.Device = device;
            this.Effect = effect;

            this.VerticesCount = Width * Length;
            this.IndexCount = (Width - 1) * (Length - 1) * 6;

            this.VertexBuffer = new VertexBuffer(device,
                typeof(VertexPositionNormalTexture), VerticesCount,
                BufferUsage.WriteOnly);

            this.IndexBuffer = new IndexBuffer(device,
                IndexElementSize.ThirtyTwoBits,
                IndexCount, BufferUsage.WriteOnly);

            ComputeHeights();
            CreateVertices();
            CreateIndices();
            ComputeNormals();

            this.VertexBuffer.SetData<VertexPositionNormalTexture>(Vertices);
            this.IndexBuffer.SetData<int>(Indexes);
        }

        public void Render( ViewRenderArguments args )
        {
            if ( Indicies.Count == 0 ) return;

            var device = args.Device;

            if ( VB==null || VB.Description.SizeInBytes < Vertex.Size * Verticies.Count ) {
                using ( VB ) {}
                using ( IB ) {}
                VB = new VertexBuffer( device, Vertex.Size * Verticies.Count, Usage.None, Vertex.FVF, Pool.Managed );
                IB = new IndexBuffer(  device, sizeof(uint)* Indicies .Count, Usage.None, Pool.Managed, false );
            }

            var vb = VB.Lock(0,0,LockFlags.None);
            vb.WriteRange(Verticies.ToArray());
            VB.Unlock();

            var ib = IB.Lock(0,0,LockFlags.None);
            ib.WriteRange(Indicies.ToArray());
            IB.Unlock();

            device.SetTexture(0,null);
            device.Indices = IB;
            device.VertexFormat = Vertex.FVF;
            device.SetStreamSource(0,VB,0,Vertex.Size);
            device.DrawIndexedPrimitives(PrimitiveType.TriangleList,0,0,Verticies.Count,0,Verticies.Count/2);

            Indicies.Clear();
            Verticies.Clear();
        }

 public static void DrawColoredRectangle(Device dev,RectangleF rect,Color color)
 {
     VertexBuffer vb=null;
     IndexBuffer ib=null;
     try{
         int colorArgb=color.ToArgb();
         CustomVertex.PositionColored[] quadVerts=new CustomVertex.PositionColored[] {
                 new CustomVertex.PositionColored(rect.Left,rect.Bottom,0,colorArgb),
                 new CustomVertex.PositionColored(rect.Left,rect.Top,0,colorArgb),
                 new CustomVertex.PositionColored(rect.Right,rect.Top,0,colorArgb),
                 new CustomVertex.PositionColored(rect.Right,rect.Bottom,0,colorArgb),
             };
         vb=new VertexBuffer(typeof(CustomVertex.PositionColored),
             CustomVertex.PositionColored.StrideSize*quadVerts.Length,
             dev,Usage.WriteOnly,CustomVertex.PositionColored.Format,Pool.Managed);
         vb.SetData(quadVerts,0,LockFlags.None);
         int[] indicies=new int[] { 0,1,2,0,2,3 };
         ib=new IndexBuffer(typeof(int),indicies.Length,dev,Usage.None,Pool.Managed);
         ib.SetData(indicies,0,LockFlags.None);
         dev.VertexFormat=CustomVertex.PositionColored.Format;
         dev.SetStreamSource(0,vb,0);
         dev.Indices=ib;
         dev.DrawIndexedPrimitives(PrimitiveType.TriangleList,0,0,quadVerts.Length,0,indicies.Length/3);
     }finally{
         if(vb!=null){
             vb.Dispose();
             vb=null;
         }
         if(ib!=null){
             ib.Dispose();
             ib=null;
         }
     }
 }

 public IRenderRequest CreateInstancedRequest(IRenderContext renderContext, RasterizerState rasterizerState,
     BlendState blendState, DepthStencilState depthStencilState, IEffect effect, IEffectParameterSet effectParameterSet,
     VertexBuffer meshVertexBuffer, IndexBuffer meshIndexBuffer, PrimitiveType primitiveType,
     Matrix[] instanceWorldTransforms, Action<List<Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
 {
     throw new NotImplementedException();
 }

        public static void CreateIndexBuffer(Device gDevice, int width, int height, out IndexBuffer iBuffer)
        {
            // create buffer
            iBuffer = new IndexBuffer(typeof(int), (width - 1) * (height - 1) * 6, gDevice, Usage.WriteOnly, Pool.Managed);
            int[] indices = (int[])iBuffer.Lock(0, LockFlags.None);
            
            // fill buffer
            int bufIdx = 0;
            for (int y = 0; y < height - 1; y++)
            {
                for (int x = 0; x < width - 1; x++)
                {
                    // fill quad (2xtri)
                    int pos = (y * width) + x;
                    indices[bufIdx++] = pos;
                    indices[bufIdx++] = pos + width;
                    indices[bufIdx++] = pos + 1;

                    indices[bufIdx++] = pos + 1;
                    indices[bufIdx++] = pos + width;
                    indices[bufIdx++] = pos + 1 + width;
                }
            }
            iBuffer.Unlock();
        }

 protected virtual void InitBuffers(GraphicsDevice graphics)
 {
     _vertexBuffer = new VertexBuffer(graphics, VertexPositionColorNormal.VertexDeclaration, _vertices.Length, BufferUsage.None);
     _vertexBuffer.SetData<VertexPositionColorNormal>(_vertices);
     _indexBuffer = new IndexBuffer(graphics, IndexElementSize.ThirtyTwoBits, _indices.Length, BufferUsage.None);
     _indexBuffer.SetData<int>(_indices);
 }

        public Doom3Map(Doom3MapData map)
        {
            Surfaces=new List<Surface>();
            int verts = 0;
            int indices = 0;
            foreach(Doom3MapData.Model m in map.Models)
            {
                foreach(Doom3MapData.Surface s in m.Surfaces)
                {
                    VertexBuffer vb = Root.Instance.UserInterface.Renderer.CreateStaticVertexBuffer(
                        s.Vertices,
                        s.Vertices.Length*4*(3+2+3)
                        );
                    vb.Format = VertexFormat.VF_P3T2N3;

                    IndexBuffer ib = new IndexBuffer();
                    ib.buffer = new int[s.Indices.Length];
                    for (int i = 0; i < ib.buffer.Length; ++i)
                        ib.buffer[i] = s.Indices[i];

                    Surface s2 = new Surface();
                    s2.Ibuffer = ib;
                    s2.Vbuffer = vb;
                    verts += s.Vertices.Length;
                    indices += s.Indices.Length;
                    Texture t=null;
                    try
                    {
                        t = Root.Instance.ResourceManager.LoadTexture(s.Name + ".tga");
                    }
                    catch (Exception)
                    {
                        try
                        {
                            t = Root.Instance.ResourceManager.LoadTexture(s.Name + "_add.tga");
                        }
                        catch (Exception)
                        {
                            try
                            {
                                t = Root.Instance.ResourceManager.LoadTexture(s.Name + "_d.tga");
                            }
                            catch (Exception )
                            {
                                System.Console.WriteLine("warning: cant load "+s.Name);
                            }
                        }
                    }
                    s2.Material=Material.CreateSimpleMaterial(t);
                    //s2.Material.Additive = true;
                    Surfaces.Add(s2);
                }
            }
            System.Console.WriteLine("surfaces: "+Surfaces.Count.ToString());
            System.Console.WriteLine("verts: " + verts.ToString());
            System.Console.WriteLine("indices: " + indices.ToString());

            GC.Collect();
            BBox = new BoundingBox(map.BBoxMin, map.BBoxMax);
        }

        public static void CreateIndices(GraphicsDevice graphicsDevice, int patchWidth, int patchHeight)
        {
            IndexCount = (patchWidth - 1) * (patchHeight - 1) * 6;

              indexData = new short[IndexCount];

              for (int y = 0; y < patchHeight - 1; y++)
            for (int x = 0; x < patchWidth - 1; x++)
            {
              int i = (y * (patchWidth - 1) + x) * 6;

              // lower left triangle
              indexData[i + 0] = (short)((y + 1) * patchWidth + (x + 0));  // top left vertex
              indexData[i + 1] = (short)((y + 1) * patchWidth + (x + 1));  // top right vertex
              indexData[i + 2] = (short)((y + 0) * patchWidth + (x + 0));  // lower left vertex

              // top right triangle
              indexData[i + 3] = (short)((y + 1) * patchWidth + (x + 1));  // top right vertex
              indexData[i + 4] = (short)((y + 0) * patchWidth + (x + 1));  // lower right vertex
              indexData[i + 5] = (short)((y + 0) * patchWidth + (x + 0));  // lower left vertex
            }

              Indices = new IndexBuffer(graphicsDevice, typeof(short), IndexCount, BufferUsage.WriteOnly);
              Indices.SetData<short>(indexData);
        }