C# GraphicsDevice.DrawPrimitives方法代码示例

        public static void Render(BoundingSphere sphere,
                                  GraphicsDevice graphicsDevice,
                                  Matrix view,
                                  Matrix projection,
                                  Color color,
                                  Guid id)
        {
            var subscription = Subscriptions[id];

            graphicsDevice.SetVertexBuffer(subscription.VertexBuffer);
            subscription.BasicEffect.World = Matrix.CreateScale(sphere.Radius)*
                                                   Matrix.CreateTranslation(sphere.Center);
            subscription.BasicEffect.View = view;
            subscription.BasicEffect.Projection = projection;
            subscription.BasicEffect.DiffuseColor = color.ToVector3();

            foreach (var pass in subscription.BasicEffect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawPrimitives(PrimitiveType.LineStrip, 0, SphereResolution);
                graphicsDevice.DrawPrimitives(PrimitiveType.LineStrip,
                                              SphereResolution + 1,
                                              SphereResolution);
                graphicsDevice.DrawPrimitives(PrimitiveType.LineStrip,
                                              (SphereResolution + 1)*2,
                                              SphereResolution);
            }
        }

        public void Draw(GraphicsDevice device, BasicEffect effect)
        {
            if (buf == null)
            {
                buf = new VertexBuffer(device, typeof(VertexPositionTexture), 4, BufferUsage.None);
                var vpt = new VertexPositionTexture[4]{
                    new VertexPositionTexture(new Vector3(0, 0, 0), new Vector2(0,0)),
                    new VertexPositionTexture(new Vector3(SIZE, 0, 0), new Vector2(1,0)),
                    new VertexPositionTexture(new Vector3(0, 0, SIZE), new Vector2(0,1)),
                    new VertexPositionTexture(new Vector3(SIZE, 0, SIZE), new Vector2(1,1))
                };

                buf.SetData(vpt);
            }

            device.SetVertexBuffer(buf);

            effect.TextureEnabled = true;
            effect.Texture = texture;

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
            }
        }

        public override void RenderToDevice(GraphicsDevice device, BasicEffect basicEffet)
        {
            if (basicEffet.LightingEnabled)
            {

                // Build the cube, setting up the _vertices array
                if (isConstructed == false)
                    Construct();

                // Create the shape buffer and dispose of it to prevent out of memory
                using (VertexBuffer buffer = new VertexBuffer(
                    device,
                    VertexPositionNormalTexture.VertexDeclaration,
                    NUM_VERTICES,
                    BufferUsage.WriteOnly))
                {
                    // Load the buffer
                    buffer.SetData(_vertices);
                    // Send the vertex buffer to the device
                    device.SetVertexBuffer(buffer);
                    // Draw the primitives from the vertex buffer to the device as triangles
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, NUM_TRIANGLES);
                }
            }
        }

        /// <summary>
        /// Draws the Sphere
        /// </summary>
        /// <param name="device">Graphics device</param>
        /// <param name="camera">What camera to draw on</param>
        public void draw(GraphicsDevice device)
        {
            device.VertexDeclaration = vDecl;
            device.Vertices[0].SetSource(vBuffer, 0, vertexPos.SizeInBytes);

            device.DrawPrimitives(PrimitiveType.TriangleList, 0, numV / 2);
        }

        /// <summary>
        /// Draws the primitive to the screen.
        /// </summary>
        /// <param Name="device">GPU to draw with.</param>
        public virtual void Render(GraphicsDevice device)
        {
            lock (VertexLock)
            {
            #if MONOGAME_BUILD
                device.SamplerStates[0].Filter = TextureFilter.Point;
                device.SamplerStates[1].Filter = TextureFilter.Point;
                device.SamplerStates[2].Filter = TextureFilter.Point;
                device.SamplerStates[3].Filter = TextureFilter.Point;
                device.SamplerStates[4].Filter = TextureFilter.Point;
            #endif
                if (VertexBuffer == null)
                {
                    return;
                }

                if (Vertices == null || VertexBuffer == null || Vertices.Length < 3 ||  VertexBuffer.IsDisposed || VertexBuffer.VertexCount < 3)
                {
                    return;
                }

                device.SetVertexBuffer(VertexBuffer);

                if (IndexBuffer != null)
                {
                    device.Indices = IndexBuffer;
                    device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, VertexBuffer.VertexCount, 0, IndexBuffer.IndexCount / 3);
                }
                else
                {
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, Vertices.Length/3);
                }
            }
        }

 public static void draw(GraphicsDevice device)
 {
     if (vBuffer == null)
     {
         vBuffer = CreateVertexBuffer(device);
     }
     device.SetVertexBuffer(vBuffer);
     device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
 }

 /// <summary>
 /// Draws the primitive to the screen.
 /// </summary>
 /// <param name="device">GPU to draw with.</param>
 public virtual void RenderWireframe(GraphicsDevice device)
 {
     RasterizerState state = new RasterizerState();
     RasterizerState oldState = device.RasterizerState;
     state.FillMode = FillMode.WireFrame;
     device.RasterizerState = state;
     device.SetVertexBuffer(m_vertexBuffer);
     device.DrawPrimitives(PrimitiveType.TriangleList, 0, m_vertices.Length / 3);
     device.RasterizerState = oldState;
 }

        /// <summary>
        /// Draws the primitive to the screen.
        /// </summary>
        /// <param name="device">GPU to draw with.</param>
        public virtual void Render(GraphicsDevice device)
        {
            if (m_vertices == null || m_vertexBuffer == null || m_vertexBuffer.IsDisposed)
            {
                return;
            }

            device.SetVertexBuffer(m_vertexBuffer);
            device.DrawPrimitives(PrimitiveType.TriangleList, 0, m_vertices.Length / 3);
        }

		/// <summary>
		/// Draws the vertice list on the given surface.
		/// </summary>
		/// <param name="device"></param>
		/// <param name="effect"></param>
		/// <param name="matrixView"></param>
		/// <param name="matrixProjection"></param>
		/// <param name="matrixWorld"></param>
		public void Draw(GraphicsDevice device, BasicEffect effect, Matrix matrixView, Matrix matrixProjection, Matrix matrixWorld) {
			effect.CurrentTechnique.Passes[0].Apply();

			effect.Projection = matrixProjection;
			effect.World = matrixWorld;
			effect.View = matrixView;

			//Device.VertexDeclaration = mVertexDeclaration;
			//Device.Vertices[0].SetSource(mVertexBuffer, 0, VertexPositionColorTexture.SizeInBytes);
			device.SetVertexBuffer(mVertexBuffer);
			device.DrawPrimitives(PrimitiveType.TriangleList, 0, mVerticesList.Count);
		}

        public void Draw(GraphicsDevice graphicsDevice, Effect effect,
            string colorMapParamName, string normalMapParamName,
            Texture2D ColorMap, Texture2D NormalMap)
        {
            graphicsDevice.SetVertexBuffer(vertexBuffer);

            effect.Parameters[colorMapParamName].SetValue(ColorMap);
            effect.Parameters[normalMapParamName].SetValue(NormalMap);

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 2);
            }
        }

        public void RenderFloor(GraphicsDevice gd, Camera camera)
        {
            BuildFloor();

            effect.TextureEnabled = true;

            buffer = new VertexBuffer(gd,
                VertexPositionNormalTexture.SizeInBytes * verticies.Length,
                BufferUsage.WriteOnly);
            buffer.SetData(verticies);

            gd.Vertices[0].SetSource(buffer, 0,
                VertexPositionNormalTexture.SizeInBytes);
            gd.VertexDeclaration = new VertexDeclaration(
                gd, VertexPositionNormalTexture.VertexElements);
            gd.DrawPrimitives(PrimitiveType.TriangleList, 0, triangles);
        }

        public void Draw(GraphicsDevice graphicsDevice,Effect effect,
            string colorMapParamName,string normalMapParamName,
            Texture2D wallColorMap,Texture2D wallNormalMap,
            Texture2D floorColorMap,Texture2D floorNormalMap,
            Texture2D ceilingColorMap,Texture2D ceilingNormalMap)
        {
            // Draw the scene geometry.
            graphicsDevice.SetVertexBuffer(vertexBuffer);

            // Draw the walls.

            effect.Parameters[colorMapParamName].SetValue(wallColorMap);
            effect.Parameters[normalMapParamName].SetValue(wallNormalMap);

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, wallsIndex, 8);
            }

            // Draw the ceiling.

            effect.Parameters[colorMapParamName].SetValue(ceilingColorMap);
            effect.Parameters[normalMapParamName].SetValue(ceilingNormalMap);

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, ceilingIndex, 2);
            }

            // Draw the floor.

            effect.Parameters[colorMapParamName].SetValue(floorColorMap);
            effect.Parameters[normalMapParamName].SetValue(floorNormalMap);

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, floorIndex, 2);
            }
        }

        public override void Render(GameTime aTime, Camera aCamera, GraphicsDevice aDevice, SpriteBatch aBatch)
        {
            if (_verts == null)
            {
                CreateRenderElements(aDevice);
            }

            _effect.View = aCamera.View;
            _effect.Projection = aCamera.Projection;
            _effect.Begin();
            for (int i = 0; i < _effect.CurrentTechnique.Passes.Count; ++i)
            {
                _effect.CurrentTechnique.Passes[i].Begin();
                aDevice.VertexDeclaration = new VertexDeclaration(aDevice, VertexPositionColor.VertexElements);
                aDevice.Vertices[0].SetSource(_verts, 0, VertexPositionColor.SizeInBytes);
                aDevice.DrawPrimitives(PrimitiveType.LineList, 0, _primativeCount);
                _effect.CurrentTechnique.Passes[i].End();
            }
            _effect.End();
        }

        // Draws the triangle mesh.
        public void Draw(GraphicsDevice graphicsDevice, BasicEffect effect, Pose pose, Color color)
        {
            if (_vertexBuffer == null)
            return;

              // Select the vertex buffer.
              graphicsDevice.SetVertexBuffer(_vertexBuffer);

              // The parameter 'pose' defines the world matrix and can be implicitly converted to
              // a XNA Matrix.
              effect.World = pose;
              effect.DiffuseColor = color.ToVector3();

              // Draw the vertex buffer.
              foreach (EffectPass pass in effect.CurrentTechnique.Passes)
              {
            pass.Apply();
            graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, _numberOfTriangles);
              }
        }

        public void Draw(GameTime gameTime, GraphicsDevice device, Effect effect, Matrix worldViewProjectionMatrix, int resolutionWidth, int resolutionHeight)
        {
            effect.Parameters["xWorldViewProjection"].SetValue(worldViewProjectionMatrix);
            effect.Parameters["xWidth"].SetValue(resolutionWidth);
            effect.Parameters["xHeight"].SetValue(resolutionHeight);

            effect.Begin();
            foreach (SModelMesh mesh in _meshes)
            {
                effect.Parameters["xTexture"].SetValue(mesh.texture);
                foreach (EffectPass pass in effect.CurrentTechnique.Passes)
                {
                    pass.Begin();
                    device.VertexDeclaration = _vertexDeclaration;
                    device.Vertices[0].SetSource(mesh.vertexBuffer, 0, _vertexSizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, mesh.numPrimitives);
                    pass.End();
                }
            }
            effect.End();
        }