C# EffectPass.Apply方法代码示例

        public void DrawDebugWorld(DynamicsWorld world)
        {
            world.DebugDrawWorld();

            if (lines.Count == 0)
                return;

            if (effect == null)
            {
                effect = new BasicEffect(graphics.Device);
                effect.World = Microsoft.Xna.Framework.Matrix.Identity;
                effect.VertexColorEnabled = true;
            }

            effect.Projection = graphics.GetEffect().Projection;
            effect.View = graphics.GetEffect().View;

            pass = effect.CurrentTechnique.Passes[0];
            pass.Apply();

            int pointCount = lines.Count;
            int linesCount = pointCount / 2;
            VertexPositionColor[] linesArray = new VertexPositionColor[pointCount];
            for (int i = 0; i < pointCount; i++)
            {
                int color = lines[i].Color;
                linesArray[i].Color = new Color(color & 0xff, (color & 0xff00) >> 8, (color & 0xff0000) >> 16, 1);
                linesArray[i].Position = MathHelper.Convert(lines[i].Position);
            }
            graphics.Device.DrawUserPrimitives(PrimitiveType.LineList, linesArray, 0, linesCount);
            lines.Clear();
        }

        public override void Render(GraphicsDevice myDevice, EffectPass pass)
        {
            pass.Apply();

            myDevice.Textures[0] = Texture;
            myDevice.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, Vertices, 0, 4, Indexes, 0, 2);
        }

        internal void Draw(Texture2D[] textures, GraphicsDevice device, BasicEffect effect, EffectPass pass)
        {
            effect.World = displayObject.WorldTransform;
            effect.Texture = textures[displayObject.TextureIndex];
            device.SetVertexBuffer(vertexBuffer);
            device.Indices = indexBuffer;
            pass.Apply();

            device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertices.Length, 0, indices.Length / 3);
        }

        /// <summary>
        /// Draws the models managed by the batch.
        /// </summary>
        public void Draw(Effect effect, EffectParameter worldTransformsParameter, EffectParameter textureIndicesParameter, EffectPass pass)
        {
            if (vertices.Length > 0)
            {
                graphicsDevice.SetVertexBuffers(bindings);
                graphicsDevice.Indices = indexBuffer;
                worldTransformsParameter.SetValue(worldTransforms);
                textureIndicesParameter.SetValue(textureIndices);
                pass.Apply();

                graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList,
                                                     0, 0, vertices.Length,
                                                     0, indices.Length / 3);
            }
        }

        private void DrawTexture(EffectPass pass)
        {
            basicEffect.VertexColorEnabled = false;
            basicEffect.TextureEnabled = true;
            basicEffect.Texture = animals;
            pass.Apply();

            overlayVertexBuffer.SetData(OverlayVertices);
            device.SetVertexBuffer(overlayVertexBuffer);

            device.DrawIndexedPrimitives(PrimitiveType.TriangleStrip, 0, 0, indexBuffer.IndexCount, 0, indexBuffer.IndexCount - 2);
        }

        private void DrawTerrain(EffectPass pass)
        {
            basicEffect.VertexColorEnabled = true;
            basicEffect.TextureEnabled = false;
            pass.Apply();

            device.SetVertexBuffer(terrainVertexBuffer);
            device.Indices = indexBuffer;

            device.DrawIndexedPrimitives(PrimitiveType.TriangleStrip, 0, 0, indexBuffer.IndexCount, 0, indexBuffer.IndexCount - 2);
        }

        private void RenderTest(EffectPass pass, float beat)
        {
            var gemTextureOuter = Get1x1Texture(Color.Black);

            basicEffect.View = Matrix.CreateLookAt(new Vector3(0, 0, 5), Vector3.Zero, Vector3.Up);
            var gem = rings[0].gems[0];
            basicEffect.TextureEnabled = true;
            basicEffect.Texture = gemTextureOuter;
            //basicEffect.World = Matrix.CreateRotationY(beat);
            pass.Apply();

            device.SetVertexBuffer(gem.Model.VertexBufferOuter);
            device.DrawPrimitives(PrimitiveType.TriangleList, 0, gem.Model.VertexBufferOuter.VertexCount / 3);

            basicEffect.TextureEnabled = true;
            basicEffect.Texture = gem.Model.Texture;
            //basicEffect.World = Matrix.CreateRotationY(beat);
            pass.Apply();

            device.SetVertexBuffer(gem.Model.VertexBufferInner);
            device.DrawPrimitives(PrimitiveType.TriangleList, 0, gem.Model.VertexBufferInner.VertexCount / 3);
        }

        private void RenderRings(EffectPass pass, float beat)
        {
            int farRing = (int)((beat - STARTBEAT) * RINGSPERBEAT);
            if (farRing < 0)
                return;
            if (farRing >= rings.Length)
                farRing = rings.Length - 1;

            var cameraPos = new Vector3(
                GetRingCenter(beat - BEATSOFVISIBILITY * 3 / 4),
                GetFarRingDepth(beat) + BEATSOFVISIBILITY * RINGSPERBEAT * DEPTHPERRING
            );

            basicEffect.View = Matrix.CreateLookAt(cameraPos, Vector3.Add(cameraPos, -Vector3.UnitZ), Vector3.Up);

            var gemTextureOuter = Get1x1Texture(Color.Black);

            for (int i = farRing; i >= 0; i--)
            {
                foreach (Gem gem in rings[i].gems)
                {
                    basicEffect.World = gem.Scale;
                    basicEffect.World *= gem.Rotation;
                    basicEffect.World *= Matrix.CreateTranslation(new Vector3(rings[i].center, 0));
                    basicEffect.World *= Matrix.CreateTranslation(gem.Position);
                    basicEffect.TextureEnabled = true;
                    basicEffect.Texture = gemTextureOuter;
                    pass.Apply();

                    device.SetVertexBuffer(gem.Model.VertexBufferOuter);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, gem.Model.VertexBufferOuter.VertexCount / 3);

                    basicEffect.Texture = gem.Model.Texture;
                    pass.Apply();

                    device.SetVertexBuffer(gem.Model.VertexBufferInner);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, gem.Model.VertexBufferInner.VertexCount / 3);
                }

                //Stop drawing gems behind camera
                if (rings[i].gems[0].Position.Z > cameraPos.Z)
                    break;
            }
        }

        private void DrawFaceBackgrounds(EffectPass pass)
        {
            device.SetVertexBuffer(faceVertexBuffer);
            for (int i = 0; i < cubeTextures.Length; i++)
            {
                basicEffect.Texture = cubeTextures[i];
                basicEffect.World = faceWorldMatrices[i] * GetCubeWorldMatrix(Beat);
                pass.Apply();

                device.DrawPrimitives(PrimitiveType.TriangleList, 0, faceVertexBuffer.VertexCount - 2);
            }
        }

        private void DrawCutieMarks(EffectPass pass)
        {
            basicEffect.Texture = spriteSheet;

            //Start animation at beat 10 ramping up to full speed six beats later
            var skewBeat = Beat < 10 ? 0 : GetSkewBeat(Beat - 10, 6);

            for (int i = 0; i < cubeTextures.Length; i++)
            {
                basicEffect.World = faceWorldMatrices[i] * GetCubeWorldMatrix(Beat);
                pass.Apply();

                //List of VertexPositionNormalTextures to be drawn as a triangle list
                var vertices = GetPonyVertices(i, skewBeat);

                device.DrawUserPrimitives<VertexPositionNormalTexture>(PrimitiveType.TriangleList, vertices.ToArray(), 0, vertices.Count / 3);
            }
        }

        protected internal virtual bool OnNextPass(EffectTechnique technique, RenderContext context, ref int index, out EffectPass pass)
        {
            Debug.Assert(index >= 0, "Invalid index.");

              int numberOfPasses = technique.Passes.Count;
              if (index >= numberOfPasses)
              {
            // Finished: All effect passes have been applied.
            context.PassIndex = -1;
            pass = null;
            return false;
              }

              context.PassIndex = index;
              pass = technique.Passes[index];
              index++;

              if (index == numberOfPasses - 1
              && string.Equals(pass.Name, "Restore", StringComparison.OrdinalIgnoreCase))
              {
            // A last effect pass may be used to restore the default render states without
            // drawing anything. The effect pass needs to be called "Restore".
            pass.Apply();

            // Finished: All effect passes have been applied.
            context.PassIndex = -1;
            pass = null;
            return false;
              }

              return true;
        }

		public void Render(EffectWrapper pEffect, EffectPass pEffectPass)
		{
			if (m_bVisible)
			{
				pEffect.SetValue("FineBlockOrig", m_tFineBlockOrig);
				pEffect.SetValue("FineBlockOrig2", m_tFineBlockOrig2);
				pEffect.SetValue("ScaleFactor", m_tScaleFactor);
				pEffectPass.Apply();

				// render
				pEffect.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleStrip,
					0,                              // base vertex
					0,                              // min vertex index
					Settings.BLOCK_NUM_VERTICES,    // total num vertices - note that is NOT just vertices that are indexed, but all vertices
					0,                              // start index
					Settings.BLOCK_NUM_PRIMITIVES); // primitive count
			}
		}