C# GraphicsDevice.SetVertexBuffers方法代码示例

        public void RenderToGBuffer(Camera camera, GraphicsDevice graphicsDevice)
        {
            if (_subMeshes.Count == 0)
                return;

            // Tell the GPU to read from both the model vertex buffer plus our instanceVertexBuffer.
            Mesh.SubMesh subMesh = _subMeshes[0];
            ModelMeshPart meshPart = subMesh._meshPart;
            graphicsDevice.SetVertexBuffers(
                new VertexBufferBinding(meshPart.VertexBuffer, meshPart.VertexOffset, 0),
                new VertexBufferBinding(_instanceVertexBuffer, 0, 1)
            );

            subMesh.RenderEffect.SetCurrentTechnique(3);
            subMesh.RenderEffect.SetMatrices(Matrix.Identity, camera.EyeTransform, camera.ProjectionTransform);
            //our first pass is responsible for rendering into GBuffer
            subMesh.RenderEffect.SetFarClip(camera.FarClip);

            //no individual skinned models for now
            if (subMesh._parent.BoneMatrixes != null)
                subMesh.RenderEffect.SetBones(subMesh._parent.BoneMatrixes);

            subMesh.RenderEffect.Apply();

            graphicsDevice.Indices = meshPart.IndexBuffer;

            graphicsDevice.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0,
                                                               meshPart.NumVertices, meshPart.StartIndex,
                                                               meshPart.PrimitiveCount, _subMeshes.Count);


        }

        public void RenderToGBufferInstanced(Model model, Matrix[] modelBones, Matrix[] instances, Camera.Camera camera, GraphicsDevice graphicsDevice)
        {
            if (instances.Length == 0)
                return;

            // If we have more instances than room in our vertex buffer, grow it to the neccessary size.
            if ((instanceVertexBuffer == null) ||
                (instances.Length > instanceVertexBuffer.VertexCount))
            {
                if (instanceVertexBuffer != null)
                    instanceVertexBuffer.Dispose();

                instanceVertexBuffer = new DynamicVertexBuffer(graphicsDevice, instanceVertexDeclaration, instances.Length, BufferUsage.WriteOnly);
            }

            // Transfer the latest instance transform matrices into the instanceVertexBuffer.
            instanceVertexBuffer.SetData(instances, 0, instances.Length, SetDataOptions.Discard);

            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (ModelMeshPart meshPart in mesh.MeshParts)
                {
                    // Tell the GPU to read from both the model vertex buffer plus our instanceVertexBuffer.
                    graphicsDevice.SetVertexBuffers(new VertexBufferBinding(meshPart.VertexBuffer, meshPart.VertexOffset, 0), new VertexBufferBinding(instanceVertexBuffer, 0, 1));

                    graphicsDevice.Indices = meshPart.IndexBuffer;

                    // Set up the instance rendering effect.
                    Effect effect = _effect;

                    effect.CurrentTechnique = effect.Techniques["HardwareInstancing"];
                    //our first pass is responsible for rendering into GBuffer
                    effect.Parameters["World"].SetValue(modelBones[mesh.ParentBone.Index]);
                    effect.Parameters["View"].SetValue(camera.View);
                    effect.Parameters["Projection"].SetValue(camera.Projection);
                    effect.Parameters["WorldView"].SetValue(modelBones[mesh.ParentBone.Index] * camera.View);
                    effect.Parameters["WorldViewProjection"].SetValue(modelBones[mesh.ParentBone.Index] * camera.View * camera.Projection);
                    effect.Parameters["FarClip"].SetValue(camera.FarPlane);

                    if (((MeshTag)meshPart.Tag) != null)
                    if (((MeshTag)meshPart.Tag).Texture != null)
                    {
                        effect.Parameters["TextureEnabled"].SetValue(true);
                        effect.Parameters["Texture"].SetValue(((MeshTag)meshPart.Tag).Texture);
                    }
                    else effect.Parameters["TextureEnabled"].SetValue(false);
                    //if (effect.Parameters["Size"] != null)
                    //{
                        effect.Parameters["Size"].SetValue(new Vector2(scale.Z, scale.Y) * 10000);
                        effect.Parameters["Up"].SetValue(mode == BillboardMode.Spherical ? Up : (mode == BillboardMode.None ? Vector3.Zero : Vector3.Up));
                        effect.Parameters["Side"].SetValue(mode != BillboardMode.None ? Right : Vector3.Zero);
                    //}

                    effect.CurrentTechnique.Passes[0].Apply();
                    graphicsDevice.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0, meshPart.NumVertices, meshPart.StartIndex, meshPart.PrimitiveCount, instances.Length);
                }
            }
        }

 public void Draw(GraphicsDevice g, List<VertexHealthInstance> insts)
 {
     fxPass.Apply();
     g.Indices = ib;
     int i = insts.Count;
     while(i > MAX_COUNT) {
         insts.CopyTo(i - MAX_COUNT, instances, 0, MAX_COUNT);
         dvb.SetData(instances, 0, MAX_COUNT);
         g.SetVertexBuffers(vbBinds);
         g.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0, 4, 0, 2, MAX_COUNT);
         i -= MAX_COUNT;
         g.SetVertexBuffers(null);
     }
     insts.CopyTo(0, instances, 0, i);
     dvb.SetData(instances, 0, i);
     g.SetVertexBuffers(vbBinds);
     g.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0, 4, 0, 2, i);
 }

        private void DrawEmitter(GraphicsDevice device, Effect effect, ParticleEmitter emitter)
        {
            if (emitter.LiveParticles == 0)
                return;

            effect.Parameters["Time"].SetValue(emitter.Time);
            effect.Parameters["Acceleration"].SetValue(emitter.Acceleration);
            effect.Parameters["LifeSpan"].SetValue(emitter.LifeSpan);

            ParticleStateType[] instances = emitter.Particles;

            if (m_InstanceBuffer.VertexCount < instances.Length)
            {
                m_InstanceBuffer.Dispose();
                m_InstanceBuffer = new DynamicVertexBuffer(device, typeof(ParticleStateType), 2 * instances.Length, BufferUsage.WriteOnly);
            }

            m_InstanceBuffer.SetData(instances, 0, emitter.LiveParticles, SetDataOptions.Discard);

            var particleres = m_ParticleBuffer.GetResource();
            device.SetVertexBuffers(
                new VertexBufferBinding(particleres.Buffer, 0, 0),
                new VertexBufferBinding(m_InstanceBuffer, 0, 1)
                );

            device.Indices = m_IndexBuffer;

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                device.DrawInstancedPrimitives(PrimitiveType.TriangleList,
                    0, 0, particleres.NumVertices, 0, particleres.PrimitiveCount, emitter.LiveParticles);
            }
        }

 public void SetInstances(GraphicsDevice g)
 {
     g.SetVertexBuffers(
         new VertexBufferBinding(vbModel),
         new VertexBufferBinding(dvbInstances, 0, 1)
         );
     g.Indices = ibModel;
 }

 public void SetLightning(GraphicsDevice g)
 {
     fxParticle.ApplyLightning(g, tLightningMap);
     g.SetVertexBuffers(plBolts.VBBinds);
     g.Indices = plBolts.IBuffer;
 }

 public void SetFire(GraphicsDevice g)
 {
     fxParticle.ApplyFire(g, tFireColor, tFireNoise, tFireAlpha);
     g.SetVertexBuffers(plFires.VBBinds);
     g.Indices = plFires.IBuffer;
 }

 public void SetBullets(GraphicsDevice g)
 {
     fxParticle.ApplySimple(g, tBullet);
     g.SetVertexBuffers(plBullets.VBBinds);
     g.Indices = plBullets.IBuffer;
 }

 public void SetBloods(GraphicsDevice g)
 {
     fxParticle.ApplyAlert(g, tBlood);
     g.SetVertexBuffers(plBloods.VBBinds);
     g.Indices = plBloods.IBuffer;
 }

        public void Draw(GraphicsDevice graphicsDevice)
        {
            if (cubes.Length > 0)
            {
                Debug.AddString("Drawing cubes: " + cubes.Length);
                Array.Resize(ref instanceTransforms, cubes.Length);

                for (int i = 0; i < cubes.Length; i++)
                {
                    instanceTransforms[i] = Matrix.CreateTranslation(cubes[i].Position);
                }
                // Rysujemy wszystko za jednym zamachem

                // Poszerzany bufory jeśli potrzeba.
                if ((instanceVertexBuffer == null) || (cubes.Length > instanceVertexBuffer.VertexCount))
                {
                    if (instanceVertexBuffer != null)
                    {
                        instanceVertexBuffer.Dispose();
                    }

                    instanceVertexBuffer = new DynamicVertexBuffer(graphicsDevice, instanceVertexDeclaration,
                                                                   cubes.Length, BufferUsage.WriteOnly);
                }

                instanceVertexBuffer.SetData(instanceTransforms, 0, instanceTransforms.Length, SetDataOptions.Discard);

                foreach (ModelMesh mesh in instancedModel.Meshes)
                {
                    foreach (ModelMeshPart meshPart in mesh.MeshParts)
                    {
                        // Tell the GPU to read from both the model vertex buffer plus our instanceVertexBuffer.
                        graphicsDevice.SetVertexBuffers(
                            new VertexBufferBinding(meshPart.VertexBuffer, meshPart.VertexOffset, 0),
                            new VertexBufferBinding(instanceVertexBuffer, 0, 1)
                            );

                        graphicsDevice.Indices = meshPart.IndexBuffer;

                        // Set up the instance rendering effect.
                        Effect effect = meshPart.Effect;

                        effect.CurrentTechnique = effect.Techniques["SKraft"];

                        effect.Parameters["World"].SetValue(instancedModelBones[mesh.ParentBone.Index]);
                        effect.Parameters["View"].SetValue(Camera.ActiveCamera.View);
                        effect.Parameters["Projection"].SetValue(Camera.ActiveCamera.Projection);
                        //effect.Parameters["Texture"].SetValue(content.Load<Texture2D>(@"textures\texture2low2"));

                        foreach (EffectPass pass in effect.CurrentTechnique.Passes)
                        {
                            pass.Apply();

                            graphicsDevice.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0,
                                                                   meshPart.NumVertices, meshPart.StartIndex,
                                                                   meshPart.PrimitiveCount, cubes.Length);
                        }
                    }
                }
            }
        }

        public void ReconstructShading(Camera camera, GraphicsDevice graphicsDevice)
        {

            if (_subMeshes.Count == 0)
                return;

            // Tell the GPU to read from both the model vertex buffer plus our instanceVertexBuffer.
            Mesh.SubMesh subMesh = _subMeshes[0];
            ModelMeshPart meshPart = subMesh._meshPart;
            graphicsDevice.SetVertexBuffers(
                new VertexBufferBinding(meshPart.VertexBuffer, meshPart.VertexOffset, 0),
                new VertexBufferBinding(_instanceVertexBuffer, 0, 1)
            );

            subMesh.RenderEffect.SetCurrentTechnique(4);

            subMesh.RenderEffect.Apply();

            graphicsDevice.Indices = meshPart.IndexBuffer;

            graphicsDevice.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0,
                                                               meshPart.NumVertices, meshPart.StartIndex,
                                                               meshPart.PrimitiveCount, _subMeshes.Count);


        }

        public virtual void RenderShadowMap(ref Matrix viewProj, GraphicsDevice graphicsDevice)
        {
            if (_subMeshes.Count == 0)
                return;

            // Tell the GPU to read from both the model vertex buffer plus our instanceVertexBuffer.
            Mesh.SubMesh subMesh = _subMeshes[0];
            ModelMeshPart meshPart = subMesh._meshPart;
            graphicsDevice.SetVertexBuffers(
                new VertexBufferBinding(meshPart.VertexBuffer, meshPart.VertexOffset, 0),
                new VertexBufferBinding(_instanceVertexBuffer, 0, 1)
            );

            subMesh.RenderEffect.SetCurrentTechnique(5);
            subMesh.RenderEffect.SetLightViewProj(viewProj);


            //we need to set this every frame, there are situations where the object is not on screen but it still cast shadows
            subMesh.RenderEffect.SetWorld(Matrix.Identity);
            //no individual skinned models for now
            if (subMesh._parent.BoneMatrixes != null)
                subMesh.RenderEffect.SetBones(subMesh._parent.BoneMatrixes);


            subMesh.RenderEffect.Apply();

            graphicsDevice.Indices = meshPart.IndexBuffer;

            graphicsDevice.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0,
                                                               meshPart.NumVertices, meshPart.StartIndex,
                                                               meshPart.PrimitiveCount, _subMeshes.Count);

        }