C# EffectParameter.SetValue方法代码示例

        public PointLight(Vector3 position, Vector3 color, EffectParameter lightParameter)
        {
            this.position = position;
            this.color = color;
            this.lightParameter = lightParameter;

            positionParameter = lightParameter.StructureMembers["vPosition"];
            rangeParameter = lightParameter.StructureMembers["fRange"];
            colorParameter = lightParameter.StructureMembers["vColor"];

            lightParameter.StructureMembers["fFalloff"].SetValue(2.0f);
            positionParameter.SetValue(position);
            positionParameter.SetValue(position);
            rangeParameter.SetValue(100);
            colorParameter.SetValue(color);
        }

 internal static EffectDirtyFlags SetWorldViewProjAndFog(EffectDirtyFlags dirtyFlags, ref Matrix world, ref Matrix view, ref Matrix projection, ref Matrix worldView, bool fogEnabled, float fogStart, float fogEnd, EffectParameter worldViewProjParam, EffectParameter fogVectorParam)
 {
   if ((dirtyFlags & EffectDirtyFlags.WorldViewProj) != ~EffectDirtyFlags.All)
   {
     Matrix.Multiply(ref world, ref view, out worldView);
     Matrix result;
     Matrix.Multiply(ref worldView, ref projection, out result);
     worldViewProjParam.SetValue(result);
     dirtyFlags &= ~EffectDirtyFlags.WorldViewProj;
   }
   if (fogEnabled)
   {
     if ((dirtyFlags & (EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable)) != ~EffectDirtyFlags.All)
     {
       EffectHelpers.SetFogVector(ref worldView, fogStart, fogEnd, fogVectorParam);
       dirtyFlags &= ~(EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable);
     }
   }
   else if ((dirtyFlags & EffectDirtyFlags.FogEnable) != ~EffectDirtyFlags.All)
   {
     fogVectorParam.SetValue(Vector4.Zero);
     dirtyFlags &= ~EffectDirtyFlags.FogEnable;
   }
   return dirtyFlags;
 }

        /// <summary>
        /// Lazily recomputes the world inverse transpose matrix and
        /// eye position based on the current effect parameter settings.
        /// </summary>
        internal static EffectDirtyFlags SetLightingMatrices(EffectDirtyFlags dirtyFlags, ref Matrix world, ref Matrix view,
                                                             EffectParameter worldParam, EffectParameter worldInverseTransposeParam, EffectParameter eyePositionParam)
        {
            // Set the world and world inverse transpose matrices.
            if ((dirtyFlags & EffectDirtyFlags.World) != 0)
            {
                Matrix worldTranspose;
                Matrix worldInverseTranspose;

                Matrix.Invert(ref world, out worldTranspose);
                Matrix.Transpose(ref worldTranspose, out worldInverseTranspose);

                worldParam.SetValue(world);
                worldInverseTransposeParam.SetValue(worldInverseTranspose);

                dirtyFlags &= ~EffectDirtyFlags.World;
            }

            // Set the eye position.
            if ((dirtyFlags & EffectDirtyFlags.EyePosition) != 0)
            {
                Matrix viewInverse;

                Matrix.Invert(ref view, out viewInverse);

                eyePositionParam.SetValue(viewInverse.Translation);

                dirtyFlags &= ~EffectDirtyFlags.EyePosition;
            }

            return dirtyFlags;
        }

        protected override void OnInit()
        {
            base.OnInit();
            Texture2D texture = Texture;

            dtAfterGolUpdate = 0f;
            golUpdatePeriod = 60f / 140f;
            needFirstUpdate = true;

            spriteBatch = new SpriteBatch(Screen.graphicsDevice);
            eff = TTengineMaster.ActiveGame.Content.Load<Effect>("Effects/GoL");
            effTime = eff.Parameters["Time"];
            effDeltaPixelX = eff.Parameters["DeltaPixelX"];
            effDeltaPixelY = eff.Parameters["DeltaPixelY"];
            effDoGolUpdate = eff.Parameters["DoGolUpdate"];
            effDeltaPixelX.SetValue(1f/((float)texture.Width));
            effDeltaPixelY.SetValue(1f / ((float)texture.Height));
            VertexShaderInit(eff);

            renderBufInput = new RenderTarget2D(spriteBatch.GraphicsDevice, texture.Width, texture.Height);
            renderBufOutput = new RenderTarget2D(spriteBatch.GraphicsDevice, texture.Width, texture.Height);
            blendState = new BlendState();
            blendState.AlphaDestinationBlend = Blend.Zero;
            // first time rendering into buffer using BufferInit technique
            eff.CurrentTechnique = eff.Techniques[0];
            spriteBatch.Begin(SpriteSortMode.Deferred,blendState,null,null,null,eff);
            spriteBatch.GraphicsDevice.SetRenderTarget(renderBufInput);
            spriteBatch.Draw(texture, renderBufInput.Bounds, Color.White);
            spriteBatch.End();
        }

		public SpriteLinesEffect() : base( Core.graphicsDevice, EffectResource.spriteLinesEffectBytes )
		{
			_lineColorParam = Parameters["_lineColor"];
			_lineSizeParam = Parameters["_lineSize"];

			_lineColorParam.SetValue( _lineColor );
			_lineSizeParam.SetValue( _lineSize );
		}

		public DotsEffect() : base( Core.graphicsDevice, EffectResource.dotsBytes )
		{
			_scaleParam = Parameters["scale"];
			_angleParam = Parameters["angle"];

			_scaleParam.SetValue( _scale );
			_angleParam.SetValue( _angle );
		}

		public ScanlinesEffect() : base( Core.graphicsDevice, EffectResource.scanlinesBytes )
		{
			_attenuationParam = Parameters["_attenuation"];
			_linesFactorParam = Parameters["_linesFactor"];

			_attenuationParam.SetValue( _attenuation );
			_linesFactorParam.SetValue( _linesFactor );
		}

		public override void onAddedToScene()
		{
			effect = scene.content.loadEffect<Effect>( "vignette", EffectResource.letterboxBytes );

			_colorParam = effect.Parameters["_color"];
			_letterboxSizeParam = effect.Parameters["_letterboxSize"];
			_colorParam.SetValue( _color.ToVector4() );
			_letterboxSizeParam.SetValue( _letterboxSize );
		}

 private static void SetFogVector(ref Matrix worldView, float fogStart, float fogEnd, EffectParameter fogVectorParam)
 {
   if ((double) fogStart == (double) fogEnd)
   {
     fogVectorParam.SetValue(new Vector4(0.0f, 0.0f, 0.0f, 1f));
   }
   else
   {
     float num = (float) (1.0 / ((double) fogStart - (double) fogEnd));
     fogVectorParam.SetValue(new Vector4()
     {
       X = worldView.M13 * num,
       Y = worldView.M23 * num,
       Z = worldView.M33 * num,
       W = (worldView.M43 + fogStart) * num
     });
   }
 }

        public override void onAddedToScene()
        {
            effect = scene.contentManager.loadEffect<Effect>( "vignette", EffectResource.vignetteBytes );

            _powerParam = effect.Parameters["_power"];
            _radiusParam = effect.Parameters["_radius"];
            _powerParam.SetValue( _power );
            _radiusParam.SetValue( _radius );
        }

 public static void m000001()
 {
     f000058 = new SpriteBatch(c000074.m0000d4());
     f0000c1 = c000074.f0000b0.Load<Effect>("Blur");
     f0000e0 = f0000c1.Parameters["pixelSize"];
     f0000e0.SetValue(new Vector2(1f / ((float) c000074.m00000f()), 1f / ((float) c000074.m000010())));
     f0000c1.CommitChanges();
     f00000a = true;
 }

		public TwistEffect() : base( Core.graphicsDevice, EffectResource.twistBytes )
		{
			_radiusParam = Parameters["radius"];
			_angleParam = Parameters["angle"];
			_offsetParam = Parameters["offset"];

			_radiusParam.SetValue( _radius );
			_angleParam.SetValue( _angle );
			_offsetParam.SetValue( _offset );
		}

		public ReflectionEffect() : base( Core.graphicsDevice, EffectResource.reflectionBytes )
		{
			_reflectionIntensityParam = Parameters["_reflectionIntensity"];
			_renderTextureParam = Parameters["_renderTexture"];
			_normalMapParam = Parameters["_normalMap"];
			_matrixTransformParam = Parameters["_matrixTransform"];
			_normalMagnitudeParam = Parameters["_normalMagnitude"];

			_reflectionIntensityParam.SetValue( _reflectionIntensity );
			_normalMagnitudeParam.SetValue( _normalMagnitude );
		}

        public BlurEffect()
        {
            if (!GeneralManager.Effects.ContainsKey("Effects/Blur"))
            {
                GeneralManager.LoadEffect("Effects/Blur");
            }

            BloomEffect = GeneralManager.Effects["Effects/Blur"];
            Value = BloomEffect.Parameters["Param"];
            Value.SetValue(0.05f);
        }

        public override void onAddedToScene()
        {
            effect = scene.contentManager.loadEffect<Effect>( "pixelGlitch", EffectResource.pixelGlitchBytes );

            _verticalSizeParam = effect.Parameters["_verticalSize"];
            _horizontalOffsetParam = effect.Parameters["_horizontalOffset"];
            _screenSizeParam = effect.Parameters["_screenSize"];

            _verticalSizeParam.SetValue( _verticalSize );
            _horizontalOffsetParam.SetValue( _horizontalOffset );
            _screenSizeParam.SetValue( new Vector2( Screen.width, Screen.height ) );
        }