//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="EdgeFilter"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public EdgeFilter(IGraphicsService graphicsService) : base(graphicsService) { _effect = GraphicsService.Content.Load<Effect>("DigitalRune/PostProcessing/EdgeFilter"); _parameterViewportSize = _effect.Parameters["ViewportSize"]; _parameterHalfEdgeWidth = _effect.Parameters["HalfEdgeWidth"]; _parameterDepthThreshold = _effect.Parameters["DepthThreshold"]; _parameterDepthSensitivity = _effect.Parameters["DepthSensitivity"]; _parameterNormalThreshold = _effect.Parameters["NormalThreshold"]; _parameterNormalSensitivity = _effect.Parameters["NormalSensitivity"]; _parameterCameraBackward = _effect.Parameters["CameraBackward"]; _parameterSourceTexture = _effect.Parameters["SourceTexture"]; _parameterSilhouetteColor = _effect.Parameters["SilhouetteColor"]; _parameterCreaseColor = _effect.Parameters["CreaseColor"]; _parameterGBuffer0 = _effect.Parameters["GBuffer0"]; _parameterGBuffer1 = _effect.Parameters["GBuffer1"]; _passEdge = _effect.Techniques[0].Passes["Edge"]; _passOnePixelEdge = _effect.Techniques[0].Passes["OnePixelEdge"]; EdgeWidth = 2.0f; DepthThreshold = 0.001f; // = minDistance / farPlaneDistance DepthSensitivity = 1000; // = farPlaneDistance / (maxDistance - minDistance) NormalThreshold = 0.1f; NormalSensitivity = 2f; SilhouetteColor = new Vector4F(0, 0, 0, 1); CreaseColor = new Vector4F(0, 0, 0, 1); }
public InstancedModelDrawer(Game game) : base(game) { #if WINDOWS var resourceContentManager = new ResourceContentManager(game.Services, Indiefreaks.Xna.BEPU.Resources.WindowsPhysicsResources.ResourceManager); #elif XBOX360 var resourceContentManager = new ResourceContentManager(game.Services, Indiefreaks.Xna.BEPU.Resources.Xbox360PhysicsResources.ResourceManager); #else ResourceContentManager resourceContentManager = null; #endif instancingEffect = resourceContentManager.Load<Effect>("InstancedEffect"); worldTransformsParameter = instancingEffect.Parameters["WorldTransforms"]; textureIndicesParameter = instancingEffect.Parameters["TextureIndices"]; viewParameter = instancingEffect.Parameters["View"]; projectionParameter = instancingEffect.Parameters["Projection"]; instancingEffect.Parameters["LightDirection1"].SetValue(Vector3.Normalize(new Vector3(.8f, -1.5f, -1.2f))); instancingEffect.Parameters["DiffuseColor1"].SetValue(new Vector3(.66f, .66f, .66f)); instancingEffect.Parameters["LightDirection2"].SetValue(Vector3.Normalize(new Vector3(-.8f, 1.5f, 1.2f))); instancingEffect.Parameters["DiffuseColor2"].SetValue(new Vector3(.3f, .3f, .5f)); instancingEffect.Parameters["AmbientAmount"].SetValue(.5f); instancingEffect.Parameters["Texture0"].SetValue(textures[0]); instancingEffect.Parameters["Texture1"].SetValue(textures[1]); instancingEffect.Parameters["Texture2"].SetValue(textures[2]); instancingEffect.Parameters["Texture3"].SetValue(textures[3]); instancingEffect.Parameters["Texture4"].SetValue(textures[4]); instancingEffect.Parameters["Texture5"].SetValue(textures[5]); instancingEffect.Parameters["Texture6"].SetValue(textures[6]); instancingEffect.Parameters["Texture7"].SetValue(textures[7]); //This vertex declaration could be compressed or made more efficient, but such optimizations weren't critical. instancingVertexDeclaration = new VertexDeclaration(new[] {new VertexElement(0, VertexElementFormat.Single, VertexElementUsage.TextureCoordinate, 1)}); }
public InstancedModelDrawer(Game game) : base(game) { var resourceContentManager = new ResourceContentManager(game.Services, DrawerResource.ResourceManager); #if WINDOWS instancingEffect = resourceContentManager.Load<Effect>("InstancedEffect"); #else instancingEffect = resourceContentManager.Load<Effect>("InstancedEffectXbox"); #endif //instancingEffect = game.Content.Load<Effect>("InstancedEffect"); worldTransformsParameter = instancingEffect.Parameters["WorldTransforms"]; textureIndicesParameter = instancingEffect.Parameters["TextureIndices"]; viewParameter = instancingEffect.Parameters["View"]; projectionParameter = instancingEffect.Parameters["Projection"]; instancingEffect.Parameters["LightDirection1"].SetValue(Vector3.Normalize(new Vector3(.8f, -1.5f, -1.2f))); instancingEffect.Parameters["DiffuseColor1"].SetValue(new Vector3(.66f, .66f, .66f)); instancingEffect.Parameters["LightDirection2"].SetValue(Vector3.Normalize(new Vector3(-.8f, 1.5f, 1.2f))); instancingEffect.Parameters["DiffuseColor2"].SetValue(new Vector3(.3f, .3f, .5f)); instancingEffect.Parameters["AmbientAmount"].SetValue(.5f); instancingEffect.Parameters["Colors"].SetValue(colors); }
protected override void OnInit() { base.OnInit(); depthParam = effect.Parameters["Depth"]; centerParam = effect.Parameters["Center"]; }
public ScatteringSkyRenderer(IGraphicsService graphicsService) { if (graphicsService == null) throw new ArgumentNullException("graphicsService"); if (graphicsService.GraphicsDevice.GraphicsProfile == GraphicsProfile.Reach) throw new NotSupportedException("The ScatteringSkyRenderer does not support the Reach profile."); _effect = graphicsService.Content.Load<Effect>("DigitalRune/Sky/ScatteringSky"); _parameterView = _effect.Parameters["View"]; _parameterProjection = _effect.Parameters["Projection"]; _parameterSunDirection = _effect.Parameters["SunDirection"]; _parameterRadii = _effect.Parameters["Radii"]; _parameterNumberOfSamples = _effect.Parameters["NumberOfSamples"]; _parameterBetaRayleigh = _effect.Parameters["BetaRayleigh"]; _parameterBetaMie = _effect.Parameters["BetaMie"]; _parameterGMie = _effect.Parameters["GMie"]; _parameterSunIntensity = _effect.Parameters["SunIntensity"]; _parameterTransmittance = _effect.Parameters["Transmittance"]; _parameterBaseHorizonColor = _effect.Parameters["BaseHorizonColor"]; _parameterBaseZenithColor = _effect.Parameters["BaseZenithColor"]; _passLinear = _effect.Techniques[0].Passes["Linear"]; _passGamma = _effect.Techniques[0].Passes["Gamma"]; _passLinearWithBaseColor = _effect.Techniques[0].Passes["LinearWithBaseColor"]; _passGammaWithBaseColor = _effect.Techniques[0].Passes["GammaWithBaseColor"]; _submesh = MeshHelper.GetBox(graphicsService); }
public Lighting(World world) { this.world = world; pSunColor = Shaders.Common.Parameters["vSunColor"]; pSunVector = Shaders.Common.Parameters["vSunVector"]; pAmbientColor = Shaders.Common.Parameters["vAmbientColor"]; pAmbientLight = Shaders.Common.Parameters["fAmbient"]; pNumberOfLights = Shaders.Common.Parameters["iNumLights"]; pSunIntensity = Shaders.Common.Parameters["fSunIntensity"]; pFogColor = Shaders.Common.Parameters["vFogColor"]; //Shaders.Common.Parameters["tCloudShadowMap"].SetValue(world.Game.Content.Load<Texture2D>(@"textures\sky\clouds")); Random r = new Random(); if (lights[0] == null) { for (int i = 0; i < lights.Length; i++) { Vector3 color = new Vector3(r.Next(1000) / 1000.0f, r.Next(1000) / 1000.0f, r.Next(1000) / 1000.0f); lights[i] = new PointLight(Vector3.Zero, color, Shaders.Common.Parameters["lights"].Elements[i]); } } // setup the shadowmap render target GraphicsDevice g = world.GraphicsDevice; PresentationParameters pp = world.GraphicsDevice.PresentationParameters; int shadowWidth = pp.BackBufferWidth; int shadowHeight = pp.BackBufferHeight; smapTarget = new RenderTarget2D(g, shadowWidth, shadowHeight, 1, SurfaceFormat.Single); smapStencilBuffer = new DepthStencilBuffer(g, shadowWidth, shadowHeight, g.DepthStencilBuffer.Format); }
public WheelMenu( MenuScreen screen, Camera camera, float wheelScale, float screenScale, float startX, float activeX, float finishX, float y) : base(screen, Vector2.Zero) { this.wheelScale = wheelScale; scaleMatrix = Matrix.CreateScale( wheelScale ); this.camera = camera; angle = MathHelper.PiOver4; TransitionOnPosition = new Vector2( startX, y ); Position = new Vector2( activeX, y ); TransitionOffPosition = new Vector2( finishX, y ); rotateSpring = new SpringInterpolater( 1, 50, SpringInterpolater.GetCriticalDamping( 50 ) ); lastX = startX; ContentManager content = screen.ScreenManager.Game.Content; entryEffect = content.Load<Effect>( "Effects/basic" ).Clone( Screen.ScreenManager.GraphicsDevice ); entryEffect.CurrentTechnique = entryEffect.Techniques["DiffuseColor"]; entryEffect.Parameters["LightingEnabled"].SetValue( false ); entryWorldEffectParameter = entryEffect.Parameters["World"]; entryViewEffectParameter = entryEffect.Parameters["View"]; entryProjectionEffectParameter = entryEffect.Parameters["Projection"]; entryDiffuseEffectParameter = entryEffect.Parameters["DiffuseMap"]; wheelModel = content.Load<CustomModel>( "Models/hamsterWheel" ); foreach ( CustomModel.ModelPart part in wheelModel.ModelParts ) { part.Effect.CurrentTechnique = part.Effect.Techniques["Color"]; part.Effect.Parameters["Color"].SetValue( new Color( Color.LightGray, 0 ).ToVector4() ); } }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="DepthOfFieldFilter"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public DepthOfFieldFilter(IGraphicsService graphicsService) : base(graphicsService) { _effect = GraphicsService.Content.Load<Effect>("DigitalRune/PostProcessing/DepthOfFieldFilter"); _screenSizeParameter = _effect.Parameters["ScreenSize"]; _depthTextureParameter = _effect.Parameters["DepthTexture"]; _nearBlurDistanceParameter = _effect.Parameters["NearBlurDistance"]; _nearFocusDistanceParameter = _effect.Parameters["NearFocusDistance"]; _farFocusDistanceParameter = _effect.Parameters["FarFocusDistance"]; _farBlurDistanceParameter = _effect.Parameters["FarBlurDistance"]; _farParameter = _effect.Parameters["Far"]; _blurTextureParameter = _effect.Parameters["BlurTexture"]; _downsampledDepthTextureParameter = _effect.Parameters["DownsampledDepthTexture"]; _downsampledCocTextureParameter = _effect.Parameters["DownsampledCocTexture"]; _offsetsParameter = _effect.Parameters["Offsets"]; _weightsParameter = _effect.Parameters["Weights"]; _sceneTextureParameter = _effect.Parameters["SceneTexture"]; _circleOfConfusionPass = _effect.CurrentTechnique.Passes["CircleOfConfusion"]; _blurPass = _effect.CurrentTechnique.Passes["Blur"]; _depthOfFieldPass = _effect.CurrentTechnique.Passes["DepthOfField"]; _downsampleFilter = PostProcessHelper.GetDownsampleFilter(graphicsService); _cocBlur = new Blur(graphicsService); _cocBlur.InitializeBoxBlur(5, false); NearBlurDistance = 2; NearFocusDistance = 5; FarFocusDistance = 6; FarBlurDistance = 10; _downsampleFactor = 2; BlurStrength = 1; }
/// <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; }
public InstancedModelDrawer(Game game) : base(game) { instancingEffect = game.Content.Load<Effect>("InstancedEffect"); worldTransformsParameter = instancingEffect.Parameters["WorldTransforms"]; textureIndicesParameter = instancingEffect.Parameters["TextureIndices"]; viewParameter = instancingEffect.Parameters["View"]; projectionParameter = instancingEffect.Parameters["Projection"]; instancingEffect.Parameters["LightDirection1"].SetValue(Vector3.Normalize(new Vector3(.8f, -1.5f, -1.2f))); instancingEffect.Parameters["DiffuseColor1"].SetValue(new Vector3(.66f, .66f, .66f)); instancingEffect.Parameters["LightDirection2"].SetValue(Vector3.Normalize(new Vector3(-.8f, 1.5f, 1.2f))); instancingEffect.Parameters["DiffuseColor2"].SetValue(new Vector3(.3f, .3f, .5f)); instancingEffect.Parameters["AmbientAmount"].SetValue(.5f); instancingEffect.Parameters["Texture0"].SetValue(textures[0]); instancingEffect.Parameters["Texture1"].SetValue(textures[1]); instancingEffect.Parameters["Texture2"].SetValue(textures[2]); instancingEffect.Parameters["Texture3"].SetValue(textures[3]); instancingEffect.Parameters["Texture4"].SetValue(textures[4]); instancingEffect.Parameters["Texture5"].SetValue(textures[5]); instancingEffect.Parameters["Texture6"].SetValue(textures[6]); instancingEffect.Parameters["Texture7"].SetValue(textures[7]); //This vertex declaration could be compressed or made more efficient, but such optimizations weren't critical. instancingVertexDeclaration = new VertexDeclaration(new[] {new VertexElement(0, VertexElementFormat.Single, VertexElementUsage.TextureCoordinate, 1)}); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="GodRayFilter"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public GodRayFilter(IGraphicsService graphicsService) : base(graphicsService) { Effect effect = GraphicsService.Content.Load<Effect>("DigitalRune/PostProcessing/GodRayFilter"); _viewportSizeParameter = effect.Parameters["ViewportSize"]; _parameters0Parameter = effect.Parameters["Parameters0"]; _parameters1Parameter = effect.Parameters["Parameters1"]; _intensityParameter = effect.Parameters["Intensity"]; _numberOfSamplesParameter = effect.Parameters["NumberOfSamples"]; _sourceTextureParameter = effect.Parameters["SourceTexture"]; _gBuffer0Parameter = effect.Parameters["GBuffer0"]; _rayTextureParameter = effect.Parameters["RayTexture"]; _createMaskPass = effect.CurrentTechnique.Passes["CreateMask"]; _blurPass = effect.CurrentTechnique.Passes["Blur"]; _combinePass = effect.CurrentTechnique.Passes["Combine"]; _downsampleFilter = graphicsService.GetDownsampleFilter(); Scale = 1; LightDirection = new Vector3F(0, -1, 0); LightRadius = 0.2f; Intensity = new Vector3F(1, 1, 1); DownsampleFactor = 4; NumberOfSamples = 8; NumberOfPasses = 2; Softness = 1; }
public DepthMapEffect(Effect cloneSource) : base(cloneSource) { world = Parameters["World"]; view = Parameters["View"]; projection = Parameters["Projection"]; }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="CubeMapShadowMaskRenderer"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public CubeMapShadowMaskRenderer(IGraphicsService graphicsService) { if (graphicsService == null) throw new ArgumentNullException("graphicsService"); _effect = graphicsService.Content.Load<Effect>("DigitalRune/Deferred/CubeMapShadowMask"); _parameterViewInverse = _effect.Parameters["ViewInverse"]; _parameterFrustumCorners = _effect.Parameters["FrustumCorners"]; _parameterGBuffer0 = _effect.Parameters["GBuffer0"]; _parameterParameters0 = _effect.Parameters["Parameters0"]; _parameterParameters1 = _effect.Parameters["Parameters1"]; _parameterParameters2 = _effect.Parameters["Parameters2"]; _parameterLightPosition = _effect.Parameters["LightPosition"]; _parameterShadowView = _effect.Parameters["ShadowView"]; _parameterJitterMap = _effect.Parameters["JitterMap"]; _parameterShadowMap = _effect.Parameters["ShadowMap"]; _parameterSamples = _effect.Parameters["Samples"]; Debug.Assert(_parameterSamples.Elements.Count == _samples.Length); // TODO: Use struct parameter. Not yet supported in MonoGame. // Struct effect parameters are not yet supported in the MonoGame effect processor. //var parameterShadow = _effect.Parameters["ShadowParam"]; //_parameterNear = parameterShadow.StructureMembers["Near"]; //... }
public CloudLayerRenderer(IGraphicsService graphicsService) { if (graphicsService == null) throw new ArgumentNullException("graphicsService"); if (graphicsService.GraphicsDevice.GraphicsProfile == GraphicsProfile.Reach) throw new NotSupportedException("The CloudLayerRenderer does not support the Reach profile."); _effect = graphicsService.Content.Load<Effect>("DigitalRune/Sky/CloudLayer"); _parameterView = _effect.Parameters["View"]; _parameterProjection = _effect.Parameters["Projection"]; _parameterSunDirection = _effect.Parameters["SunDirection"]; _parameterSkyCurvature = _effect.Parameters["SkyCurvature"]; _parameterTextureMatrix = _effect.Parameters["Matrix0"]; _parameterNumberOfSamples = _effect.Parameters["NumberOfSamples"]; _parameterSampleDistance = _effect.Parameters["SampleDistance"]; _parameterScatterParameters = _effect.Parameters["ScatterParameters"]; _parameterHorizonFade = _effect.Parameters["HorizonFade"]; _parameterSunLight = _effect.Parameters["SunLight"]; _parameterAmbientLight = _effect.Parameters["AmbientLight"]; _parameterTexture = _effect.Parameters["NoiseTexture0"]; _passCloudRgbLinear = _effect.Techniques[0].Passes["CloudRgbLinear"]; _passCloudAlphaLinear = _effect.Techniques[0].Passes["CloudAlphaLinear"]; _passCloudRgbGamma = _effect.Techniques[0].Passes["CloudRgbGamma"]; _passCloudAlphaGamma = _effect.Techniques[0].Passes["CloudAlphaGamma"]; _passOcclusionRgb = _effect.Techniques[0].Passes["OcclusionRgb"]; _passOcclusionAlpha = _effect.Techniques[0].Passes["OcclusionAlpha"]; // We render a spherical patch into the sky. But any mesh which covers the top // hemisphere works too. //_submesh = MeshHelper.CreateSpherePatch(graphicsService.GraphicsDevice, 1, 1.1f, 10); _submesh = MeshHelper.CreateBox(graphicsService.GraphicsDevice); _queryGeometry = new Vector3F[4]; }
public override void Initialize() { base.Initialize(); ball = GameContainer.Content.Load<Model>("Content\\Models\\Ball"); rubbery = GameContainer.Content.Load<Texture2D>("Content\\Textures\\Rubbery"); velvety = GameContainer.Content.Load<Effect>("Content\\Effects\\Velvety"); fxWorldInvertedTranspose = velvety.Parameters["WorldITXf"]; fxWvp = velvety.Parameters["WvpXf"]; fxWorld = velvety.Parameters["WorldXf"]; fxViewInverted = velvety.Parameters["ViewIXf"]; fxTexture = velvety.Parameters["ColorTexture"]; fxSubColor = velvety.Parameters["SubColor"]; fxDiffColor = velvety.Parameters["DiffColor"]; fxSpecColor = velvety.Parameters["SpecColor"]; for (int i = 0; i < ball.Meshes.Count; i++) { for (int j = 0; j < ball.Meshes[i].MeshParts.Count; j++) { ball.Meshes[i].MeshParts[j].Effect = velvety; } } }
public GdxSpriteBatch(GraphicsDevice graphicsDevice) { if (graphicsDevice == null) throw new ArgumentNullException("graphicsDevice"); _device = graphicsDevice; _spriteEffect = new LocalSpriteEffect(graphicsDevice); _matrixTransform = _spriteEffect.Parameters["MatrixTransform"]; _spritePass = _spriteEffect.CurrentTechnique.Passes[0]; _transformMatrix = Matrix.Identity; //_projectionMatrix = Matrix.CreateOrthographicOffCenter(0, graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height, 0, 0, 1); _projectionMatrix = XnaExt.Matrix.CreateOrthographic2D(0, 0, graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height, -1, 0); Color = Color.White; CalculateIndexBuffer(); _rasterizerScissorState = new RasterizerState() { CullMode = CullMode.None, ScissorTestEnable = true, }; // projection uses CreateOrthographicOffCenter to create 2d projection // matrix with 0,0 in the upper left. /*_basicEffect.Projection = Matrix.CreateOrthographicOffCenter (0, graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height, 0, 0, 1); this._basicEffect.World = Matrix.Identity; this._basicEffect.View = Matrix.CreateLookAt(Vector3.Zero, Vector3.Forward, Vector3.Up);*/ }
public RenderBatch(GraphicsDevice device, int primitivesPerBatch, bool enableAlphaBlend) { this.device = device; if (enableAlphaBlend) { BasicEffect be = new BasicEffect(device); Effect = be; fxMatrices = be; be.TextureEnabled = true; be.VertexColorEnabled = true; be.LightingEnabled = false; fxParamTexture = Effect.Parameters["Texture"]; } else { AlphaTestEffect ate = new AlphaTestEffect(device); Effect = ate; fxMatrices = ate; ate.VertexColorEnabled = true; ate.ReferenceAlpha = 128; fxParamTexture = Effect.Parameters["Texture"]; } this.maxPrimitivesPerBatch = primitivesPerBatch; }
public DefaultEffect(Effect effect) : base(effect) { world = Parameters["World"]; projection = Parameters["Projection"]; texture = Parameters["DiffuseTexture"]; }
protected override void _LoadParameters() { base._LoadParameters(); _baseTextureParameter = EffectManager.GetParameter(Effect, "baseTexture"); Assert.Fatal(_baseTextureParameter != null, "PostProcessMaterial._LoadParameters - Unable to load parameter 'baseTexture'!"); }
public GradientTextureSkyRenderer(IGraphicsService graphicsService) { if (graphicsService == null) throw new ArgumentNullException("graphicsService"); if (graphicsService.GraphicsDevice.GraphicsProfile == GraphicsProfile.Reach) throw new NotSupportedException("The GradientTextureSkyRenderer does not support the Reach profile."); _effect = graphicsService.Content.Load<Effect>("DigitalRune/Sky/GradientTextureSky"); _parameterView = _effect.Parameters["View"]; _parameterProjection = _effect.Parameters["Projection"]; _parameterSunDirection = _effect.Parameters["SunDirection"]; _parameterTime = _effect.Parameters["Time"]; _parameterColor = _effect.Parameters["Color"]; _parameterFrontTexture = _effect.Parameters["FrontTexture"]; _parameterBackTexture = _effect.Parameters["BackTexture"]; _parameterAbcd = _effect.Parameters["Abcd"]; _parameterEAndStrength = _effect.Parameters["EAndStrength"]; _passLinear = _effect.Techniques[0].Passes["Linear"]; _passGamma = _effect.Techniques[0].Passes["Gamma"]; _passCieLinear = _effect.Techniques[0].Passes["CieLinear"]; _passCieGamma = _effect.Techniques[0].Passes["CieGamma"]; _submesh = MeshHelper.GetBox(graphicsService); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="SsaoFilter"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public SaoFilter(IGraphicsService graphicsService) : base(graphicsService) { Effect effect = GraphicsService.Content.Load<Effect>("DigitalRune/PostProcessing/SaoFilter"); _frustumInfoParameter = effect.Parameters["FrustumInfo"]; _numberOfAOSamplesParameter = effect.Parameters["NumberOfAOSamples"]; _aoParameters0 = effect.Parameters["AOParameters0"]; _aoParameters1 = effect.Parameters["AOParameters1"]; _aoParameters2 = effect.Parameters["AOParameters2"]; _sourceTextureParameter = effect.Parameters["SourceTexture"]; _occlusionTextureParameter = effect.Parameters["OcclusionTexture"]; _gBuffer0Parameter = effect.Parameters["GBuffer0"]; //_viewParameter = _effect.Parameters["View"]; //_gBuffer1Parameter = _effect.Parameters["GBuffer1"]; _createAOPass = effect.CurrentTechnique.Passes["CreateAO"]; _blurHorizontalPass = effect.CurrentTechnique.Passes["BlurHorizontal"]; _blurVerticalPass = effect.CurrentTechnique.Passes["BlurVertical"]; _blurVerticalAndCombinePass = effect.CurrentTechnique.Passes["BlurVerticalAndCombine"]; Strength = 1; MaxOcclusion = 1; Radius = 0.5f; MinBias = 0.02f; Bias = 0.0004f; NumberOfSamples = 11; SampleDistribution = 7; BlurScale = 2; EdgeSoftness = 0.5f; CombineWithSource = true; }
public Quad( Vector3[] verts, Vector3 position, Texture2D texture ) { if ( verts.Length != 4 ) throw new InvalidOperationException( "Quad must have four vertices." ); localPositions = verts; vertices = new VertexPositionTexture[4]; Array.Copy( verts, localPositions, 4 ); vertices[0].TextureCoordinate = new Vector2( 0, 0 ); vertices[1].TextureCoordinate = new Vector2( 1, 0 ); vertices[2].TextureCoordinate = new Vector2( 1, 1 ); vertices[3].TextureCoordinate = new Vector2( 0, 1 ); Position = position; Scale = 1f; device = ZombieCraft.Instance.GraphicsDevice; vertexDeclaraion = new VertexDeclaration( device, VertexPositionTexture.VertexElements ); effect = ZombieCraft.Instance.Content.Load<Effect>( "Effects/Primitive" ).Clone( device ); effect.CurrentTechnique = effect.Techniques["Texture"]; viewParam = effect.Parameters["View"]; projectionParam = effect.Parameters["Projection"]; textureParam = effect.Parameters["Texture"]; colorParam = effect.Parameters["Color"]; Texture = texture; }
public override void Create() { buffer = Plane(xCount, yCount); //Load the correct shader and set up the parameters IGraphicsDeviceService graphicsService = (IGraphicsDeviceService)GameInstance.Services.GetService(typeof(IGraphicsDeviceService)); effect = SpacewarGame.ContentManager.Load<Effect>(SpacewarGame.Settings.MediaPath + @"shaders\sun"); worldParam = effect.Parameters["world"]; worldViewProjectionParam = effect.Parameters["worldViewProjection"]; sun0TextureParam = effect.Parameters["Sun_Tex0"]; sun1TextureParam = effect.Parameters["Sun_Tex1"]; blendFactor = effect.Parameters["blendFactor"]; //Preload the textures into the cache int numFrames = 5; sun = new Texture2D[numFrames]; sun[0] = SpacewarGame.ContentManager.Load<Texture2D>(SpacewarGame.Settings.MediaPath + @"textures\suntest1"); sun[1] = SpacewarGame.ContentManager.Load<Texture2D>(SpacewarGame.Settings.MediaPath + @"textures\suntest2"); sun[2] = SpacewarGame.ContentManager.Load<Texture2D>(SpacewarGame.Settings.MediaPath + @"textures\suntest3"); sun[3] = SpacewarGame.ContentManager.Load<Texture2D>(SpacewarGame.Settings.MediaPath + @"textures\suntest4"); sun[4] = SpacewarGame.ContentManager.Load<Texture2D>(SpacewarGame.Settings.MediaPath + @"textures\suntest5"); }
protected override void OnInit() { base.OnInit(); //Texture2D texture = Texture; effTime = eff.Parameters["Time"]; spriteSortMode = SpriteSortMode.Deferred; }
private int SetParameter(int offset, EffectParameter param) { if (param.Data == null) return 0; int num; if (param.Elements.Count > 0) { num = param.RowCount * param.Elements.Count; this.SetData(offset, param.RowCount * param.Elements.Count, param.ColumnCount, 0, param.Data); } else { switch (param.ParameterType) { case EffectParameterType.Bool: case EffectParameterType.Int32: case EffectParameterType.Single: if (param.ParameterClass == EffectParameterClass.Matrix) { num = param.ColumnCount; this.SetData(offset, param.ColumnCount, param.RowCount, param.RegisterCount, param.Data); break; } else { num = param.RowCount; this.SetData(offset, param.RowCount, param.ColumnCount, param.RegisterCount, param.Data); break; } default: throw new NotImplementedException("Not supported!"); } } return num; }
/// <summary> /// Initializes a new instance of the <see cref="CopyFilter"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public CopyFilter(IGraphicsService graphicsService) : base(graphicsService) { _effect = GraphicsService.Content.Load<Effect>("DigitalRune/PostProcessing/CopyFilter"); _sourceTextureParameter = _effect.Parameters["SourceTexture"]; _viewportSizeParameter = _effect.Parameters["ViewportSize"]; }
public ParticleEffect(Effect _fx, ParticleEffectConfig conf) { fx = _fx; fx.CurrentTechnique = fx.Techniques[0]; fxPassSimple = fx.CurrentTechnique.Passes[conf.PassSimple]; fxpVP = fx.Parameters[conf.ParamVP]; fxpTime = fx.Parameters[conf.ParamTime]; fxpMapSize = fx.Parameters[conf.ParamMapSize]; fxPassLightning = fx.CurrentTechnique.Passes[conf.PassLightning]; fxpLSplits = fx.Parameters[conf.ParamSplits]; fxPassFire = fx.CurrentTechnique.Passes[conf.PassFire]; fxpFRates = fx.Parameters[conf.ParamRates]; fxpFScales = fx.Parameters[conf.ParamScales]; fxpFOff1 = fx.Parameters[conf.ParamOffset1]; fxpFOff2 = fx.Parameters[conf.ParamOffset2]; fxpFOff3 = fx.Parameters[conf.ParamOffset3]; fxpFDistortScale = fx.Parameters[conf.ParamDistortScale]; fxpFDistortBias = fx.Parameters[conf.ParamDistortBias]; fxPassAlert = fx.CurrentTechnique.Passes[conf.PassAlert]; // Set Default Values LightningSplits = DEFAULT_SPLITS; FireDistortScale = DEFAULT_DISTORT_SCALE; FireDistortBias = DEFAULT_DISTORT_BIAS; FireOffset1 = DEFAULT_OFFSET; FireOffset2 = DEFAULT_OFFSET; FireOffset3 = DEFAULT_OFFSET; FireRates = DEFAULT_RATES; FireScales = DEFAULT_SCALES; }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="ProjectorLightRenderer"/> class. /// </summary> /// <param name="graphicsService">The graphics service.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="graphicsService"/> is <see langword="null"/>. /// </exception> public ProjectorLightRenderer(IGraphicsService graphicsService) { if (graphicsService == null) throw new ArgumentNullException("graphicsService"); _effect = graphicsService.Content.Load<Effect>("DigitalRune/Deferred/ProjectorLight"); _parameterWorldViewProjection = _effect.Parameters["WorldViewProjection"]; _parameterViewportSize = _effect.Parameters["ViewportSize"]; _parameterFrustumCorners = _effect.Parameters["FrustumCorners"]; _parameterDiffuseColor = _effect.Parameters["ProjectorLightDiffuse"]; _parameterSpecularColor = _effect.Parameters["ProjectorLightSpecular"]; _parameterPosition = _effect.Parameters["ProjectorLightPosition"]; _parameterRange = _effect.Parameters["ProjectorLightRange"]; _parameterAttenuation = _effect.Parameters["ProjectorLightAttenuation"]; _parameterTexture = _effect.Parameters["ProjectorLightTexture"]; _parameterTextureMatrix = _effect.Parameters["ProjectorLightTextureMatrix"]; _parameterGBuffer0 = _effect.Parameters["GBuffer0"]; _parameterGBuffer1 = _effect.Parameters["GBuffer1"]; _parameterShadowMaskChannel = _effect.Parameters["ShadowMaskChannel"]; _parameterShadowMask = _effect.Parameters["ShadowMask"]; _passClip = _effect.CurrentTechnique.Passes["Clip"]; _passDefaultRgb = _effect.CurrentTechnique.Passes["DefaultRgb"]; _passDefaultAlpha = _effect.CurrentTechnique.Passes["DefaultAlpha"]; _passShadowedRgb = _effect.CurrentTechnique.Passes["ShadowedRgb"]; _passShadowedAlpha = _effect.CurrentTechnique.Passes["ShadowedAlpha"]; }
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; }
public StencilSolidEffect(Effect effect) { _effect = effect; _pass = _effect.CurrentTechnique.Passes[0]; _projection = effect.Parameters["Projection"]; _transformation = effect.Parameters["Transformation"]; }
/// <summary> /// Creates a new instance of <see cref="XNAEffectParameter"/>. /// </summary> /// <param name="param">The underlying XNA effect parameter.</param> internal XNAEffectParameter(XFG.EffectParameter param) { _param = param; SetClassAndType(param.ParameterClass, param.ParameterType); _elements = new XNAEffectParameterCollection(param.Elements); _structMembers = new XNAEffectParameterCollection(param.StructureMembers); _annotations = new XNAEffectAnnotationCollection(param.Annotations); }
internal EffectParameter(EffectParameter cloneSource) { // Share all the immutable types. ParameterClass = cloneSource.ParameterClass; ParameterType = cloneSource.ParameterType; Name = cloneSource.Name; Semantic = cloneSource.Semantic; Annotations = cloneSource.Annotations; RowCount = cloneSource.RowCount; ColumnCount = cloneSource.ColumnCount; // Clone the mutable types. Elements = cloneSource.Elements.Clone(); StructureMembers = cloneSource.StructureMembers.Clone(); // The data is mutable, so we have to clone it. var array = cloneSource.Data as Array; if (array != null) { Data = array.Clone(); } StateKey = unchecked (NextStateKey++); }
private static void SetEffectParameterVector(ShaderProgram program, int location, EffectParameter param) { //int elementCount = param.RowCount * param.ColumnCount; unsafe { float[] objArray = (float[])param.Data; fixed(float *data = objArray) { if (objArray.Length == 2) { GL.Uniform2(location, 1, data); } else if (objArray.Length == 3) { GL.Uniform3(location, 1, data); } else { GL.Uniform4(location, 1, data); } } } }
public static void ApplyGL(this EffectPass pass) { // Set/get the correct shader handle/cleanups. // // TODO: This "reapply" if the shader index changes // trick is sort of ugly. We should probably rework // this to use some sort of "technique/pass redirect". // EffectPassProperties props = PropertyTable.GetValue(pass, x => { return(new EffectPassProperties(pass)); }); if (props.Effect.OnApply()) { props.Effect.CurrentTechnique.Passes[0].ApplyGL(); return; } var device = props.GraphicsDevice; ShaderProgram program = props.ShaderCache.GetProgram(props.VertexShader, props.PixelShader); GL.UseProgram(program.Program); if (props.VertexShader != null) { device.VertexShader = props.VertexShader; // Update the texture parameters. pass.SetShaderSamplers(props, props.VertexShader, device.VertexTextures, device.VertexSamplerStates); foreach (int paramIndex in props.VertexShaderParams) { EffectParameter param = props.Effect.Parameters[paramIndex]; SetEffectParameter(program, param); } // Update the constant buffers. foreach (int c in props.VertexShader.CBuffers) { device.SetConstantBuffer(ShaderStage.Vertex, c, null); } } if (props.PixelShader != null) { device.PixelShader = props.PixelShader; // Update the texture parameters. pass.SetShaderSamplers(props, props.PixelShader, device.Textures, device.SamplerStates); foreach (int paramIndex in props.PixelShaderParams) { EffectParameter param = props.Effect.Parameters[paramIndex]; SetEffectParameter(program, param); } // Update the constant buffers. foreach (int c in props.PixelShader.CBuffers) { device.SetConstantBuffer(ShaderStage.Pixel, c, null); } } // Set the render states if we have some. if (props.RasterizerState != null) { device.RasterizerState = props.RasterizerState; } if (props.BlendState != null) { device.BlendState = props.BlendState; } if (props.DepthStencilState != null) { device.DepthStencilState = props.DepthStencilState; } }
private static void SetEffectParameterObject(ShaderProgram program, int location, EffectParameter param) { object obj = param.Data; }
private static void SetEffectParameterMatrix(ShaderProgram program, int location, EffectParameter param) { //int elementCount = param.RowCount * param.ColumnCount; unsafe { float[] objArray = (float[])param.Data; fixed(float *data = objArray) { GL.UniformMatrix4(location, 1, false, data); } } }
/// <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); }
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); }
internal static EffectDirtyFlags SetLightingMatrices(EffectDirtyFlags dirtyFlags, ref Matrix world, ref Matrix view, EffectParameter worldParam, EffectParameter worldInverseTransposeParam, EffectParameter eyePositionParam) { if ((dirtyFlags & EffectDirtyFlags.World) != ~EffectDirtyFlags.All) { Matrix result1; Matrix.Invert(ref world, out result1); Matrix result2; Matrix.Transpose(ref result1, out result2); worldParam.SetValue(world); worldInverseTransposeParam.SetValue(result2); dirtyFlags &= ~EffectDirtyFlags.World; } if ((dirtyFlags & EffectDirtyFlags.EyePosition) != ~EffectDirtyFlags.All) { Matrix result; Matrix.Invert(ref view, out result); eyePositionParam.SetValue(result.Translation); dirtyFlags &= ~EffectDirtyFlags.EyePosition; } return(dirtyFlags); }
internal BasicDirectionalLight(EffectParameter direction, EffectParameter diffuseColor, EffectParameter specularColor) { this.directionParam = direction; this.diffuseColorParam = diffuseColor; this.specularColorParam = specularColor; }
public static bool TryParse(Stream s, GraphicsDevice g, ContentManager c, out Effect fx, ref List <object> refs, ParsingFlags ps = ParsingFlags.None) { fx = null; StreamReader f = new StreamReader(new BufferedStream(s)); // Get The Arguments From The Material File List <string[]> args = new List <string[]>(); while (!f.EndOfStream) { string line = f.ReadLine(); if (string.IsNullOrWhiteSpace(line)) { continue; } string[] split = line.Split(new string[] { "|" }, StringSplitOptions.RemoveEmptyEntries); if (split.Length < 1) { continue; } split[0] = split[0].Trim().ToLower(); switch (split[0]) { case "fx": if (split.Length >= 2) { args.Add(split); } break; case "fxpt": if (split.Length >= 3) { args.Add(split); } break; case "fxptc": if (split.Length >= 3) { args.Add(split); } break; case "fxpf": if (split.Length >= 4) { args.Add(split); } break; } } // Get The Effect For This Material Predicate <string[]> fxMatch = (a) => { return(a[0].Equals("fx")); }; string[] fxArg = args.Find(fxMatch); if (fxArg == null) { return(false); } args.RemoveAll(fxMatch); // Try To Create The Effect if (ps.HasFlag(ParsingFlags.LoadEffectByteCode)) { try { byte[] code = null; using (FileStream fxs = File.OpenRead(fxArg[1].Trim())) { code = new byte[fxs.Length]; fxs.Read(code, 0, code.Length); } fx = new Effect(g, code); } catch (Exception) { fx = null; return(false); } } else { try { fx = c.Load <Effect>(fxArg[1].Trim()); } catch (Exception) { fx = null; return(false); } } // Will Attempt To Set As Many Uniforms As Possible Without Raising Errors foreach (string[] arg in args) { switch (arg[0]) { case "fxpt": EffectParameter fxpt = fx.Parameters[arg[1].Trim()]; if (fxpt == null) { continue; } try { Texture2D t = null; if (ps.HasFlag(ParsingFlags.LoadTextureStream)) { using (FileStream ts = File.OpenRead(arg[2].Trim())) { t = Texture2D.FromStream(g, ts); } } else { t = c.Load <Texture2D>(arg[2].Trim()); } if (t != null) { refs.Add(t); fxpt.SetValue(t); } } catch (Exception) { continue; } break; case "fxptc": // Texture Cube Parameter EffectParameter fxptc = fx.Parameters[arg[1].Trim()]; if (fxptc == null) { continue; } try { TextureCube tc = c.Load <TextureCube>(arg[2].Trim()); if (tc != null) { refs.Add(tc); fxptc.SetValue(tc); } } catch (Exception) { continue; } break; case "fxpf": // Vector Parameter EffectParameter fxptv = fx.Parameters[arg[1].Trim()]; int comps; if (fxptv == null || !int.TryParse(arg[2], out comps)) { continue; } string[] sc = arg[3].Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries); if (sc.Length != comps) { continue; } switch (comps) { case 1: float v1; if (float.TryParse(sc[0], out v1)) { fxptv.SetValue(v1); } break; case 2: Vector2 v2 = Vector2.Zero; if (float.TryParse(sc[0], out v2.X) && float.TryParse(sc[1], out v2.Y) ) { fxptv.SetValue(v2); } break; case 3: Vector3 v3 = Vector3.Zero; if (float.TryParse(sc[0], out v3.X) && float.TryParse(sc[1], out v3.Y) && float.TryParse(sc[2], out v3.Z) ) { fxptv.SetValue(v3); } break; case 4: Vector4 v4 = Vector4.Zero; if (float.TryParse(sc[0], out v4.X) && float.TryParse(sc[1], out v4.Y) && float.TryParse(sc[2], out v4.Z) && float.TryParse(sc[3], out v4.W) ) { fxptv.SetValue(v4); } break; default: if (comps > 4) { float[] vn = new float[comps]; bool vnc = true; for (int i = 0; i < sc.Length && i < vn.Length && vnc; i++) { if (!float.TryParse(sc[i], out vn[i])) { vnc = false; } } if (vnc) { fxptv.SetValue(vn); } } break; } break; } } return(true); }
internal static void SetMaterialColor(bool lightingEnabled, float alpha, ref Vector3 diffuseColor, ref Vector3 emissiveColor, ref Vector3 ambientLightColor, EffectParameter diffuseColorParam, EffectParameter emissiveColorParam) { if (lightingEnabled) { Vector4 vector4 = new Vector4(); Vector3 vector3 = new Vector3(); vector4.X = diffuseColor.X * alpha; vector4.Y = diffuseColor.Y * alpha; vector4.Z = diffuseColor.Z * alpha; vector4.W = alpha; vector3.X = (emissiveColor.X + ambientLightColor.X * diffuseColor.X) * alpha; vector3.Y = (emissiveColor.Y + ambientLightColor.Y * diffuseColor.Y) * alpha; vector3.Z = (emissiveColor.Z + ambientLightColor.Z * diffuseColor.Z) * alpha; diffuseColorParam.SetValue(vector4); emissiveColorParam.SetValue(vector3); } else { diffuseColorParam.SetValue(new Vector4() { X = (diffuseColor.X + emissiveColor.X) * alpha, Y = (diffuseColor.Y + emissiveColor.Y) * alpha, Z = (diffuseColor.Z + emissiveColor.Z) * alpha, W = alpha }); } }
/// <summary> /// Looks up shortcut references to our effect parameters. /// </summary> void CacheEffectParameters() { matrixParam = Parameters["MatrixTransform"]; }
private static EffectParameterCollection ReadParameters(BinaryReader reader) { var count = (int)reader.ReadByte(); if (count == 0) { return(EffectParameterCollection.Empty); } var parameters = new EffectParameter[count]; for (var i = 0; i < count; i++) { var class_ = (EffectParameterClass)reader.ReadByte(); var type = (EffectParameterType)reader.ReadByte(); var name = reader.ReadString(); var semantic = reader.ReadString(); var annotations = ReadAnnotations(reader); var rowCount = (int)reader.ReadByte(); var columnCount = (int)reader.ReadByte(); var elements = ReadParameters(reader); var structMembers = ReadParameters(reader); object data = null; if (elements.Count == 0 && structMembers.Count == 0) { switch (type) { case EffectParameterType.Bool: case EffectParameterType.Int32: #if DIRECTX // Under DirectX we properly store integers and booleans // in an integer type. // // MojoShader on the otherhand stores everything in float // types which is why this code is disabled under OpenGL. { var buffer = new int[rowCount * columnCount]; for (var j = 0; j < buffer.Length; j++) { buffer[j] = reader.ReadInt32(); } data = buffer; break; } #endif case EffectParameterType.Single: { var buffer = new float[rowCount * columnCount]; for (var j = 0; j < buffer.Length; j++) { buffer[j] = reader.ReadSingle(); } data = buffer; break; } case EffectParameterType.String: // TODO: We have not investigated what a string // type should do in the parameter list. Till then // throw to let the user know. throw new NotSupportedException(); default: // NOTE: We skip over all other types as they // don't get added to the constant buffer. break; } } parameters[i] = new EffectParameter( class_, type, name, rowCount, columnCount, semantic, annotations, elements, structMembers, data); } return(new EffectParameterCollection(parameters)); }
private void CacheEffectParameters() { this.matrixParam = this.Parameters["MatrixTransform"]; }
private static EffectParameterCollection ReadParameters(BinaryReader reader) { var collection = new EffectParameterCollection(); var count = (int)reader.ReadByte(); if (count == 0) { return(collection); } for (var i = 0; i < count; i++) { var class_ = (EffectParameterClass)reader.ReadByte(); var type = (EffectParameterType)reader.ReadByte(); var name = reader.ReadString(); var semantic = reader.ReadString(); var annotations = ReadAnnotations(reader); var rowCount = (int)reader.ReadByte(); var columnCount = (int)reader.ReadByte(); var elements = ReadParameters(reader); var structMembers = ReadParameters(reader); object data = null; if (elements.Count == 0 && structMembers.Count == 0) { switch (type) { case EffectParameterType.Bool: case EffectParameterType.Int32: { var buffer = new int[rowCount * columnCount]; for (var j = 0; j < buffer.Length; j++) { buffer[j] = reader.ReadInt32(); } data = buffer; break; } case EffectParameterType.Single: { var buffer = new float[rowCount * columnCount]; for (var j = 0; j < buffer.Length; j++) { buffer[j] = reader.ReadSingle(); } data = buffer; break; } case EffectParameterType.String: throw new NotImplementedException(); } ; } var param = new EffectParameter( class_, type, name, rowCount, columnCount, semantic, annotations, elements, structMembers, data); collection.Add(param); } return(collection); }
public DirectionalLight(EffectParameter directionParameter, EffectParameter diffuseColorParameter, EffectParameter specularColorParameter, DirectionalLight cloneSource) { if (cloneSource != null) { this.diffuseColorParameter = cloneSource.diffuseColorParameter; this.directionParameter = cloneSource.directionParameter; this.specularColorParameter = cloneSource.specularColorParameter; this.diffuseColor = cloneSource.diffuseColor; this.direction = cloneSource.direction; this.specularColor = cloneSource.specularColor; this.enabled = cloneSource.enabled; } else { this.diffuseColorParameter = diffuseColorParameter; this.directionParameter = directionParameter; this.specularColorParameter = specularColorParameter; } }
internal EffectParameter(Effect parent, string paramName, int paramIndex, int userIndex, int uniformLocation, string paramSType, int paramLength, int numOfElements) { _parentEffect = parent; internalIndex = paramIndex; internalLength = paramLength; this.numOfElements = numOfElements; this.userIndex = userIndex; this.uniformLocation = uniformLocation; elements = new EffectParameterCollection(); // Check if the parameter is an array if (numOfElements > 1) { // We have to strip off the [0] at the end so that the // parameter can be references with just the name with no // index specifications if (paramName.EndsWith("[0]")) { paramName = paramName.Remove(paramName.Length - 3); } } name = paramName; switch (paramSType) { case "Float": paramType = EffectParameterType.Single; paramClass = EffectParameterClass.Scalar; rowCount = 1; colCount = 1; _cachedValue = 0.0f; break; case "FloatVec2": paramType = EffectParameterType.Single; paramClass = EffectParameterClass.Vector; rowCount = 1; colCount = 2; _cachedValue = MonoMac.OpenGL.Vector2.Zero; break; case "FloatVec3": paramType = EffectParameterType.Single; paramClass = EffectParameterClass.Vector; rowCount = 1; colCount = 3; _cachedValue = MonoMac.OpenGL.Vector3.Zero; break; case "FloatVec4": paramType = EffectParameterType.Single; paramClass = EffectParameterClass.Vector; rowCount = 1; colCount = 4; _cachedValue = MonoMac.OpenGL.Vector4.Zero; break; case "Sampler2D": paramType = EffectParameterType.Texture2D; paramClass = EffectParameterClass.Object; rowCount = 0; colCount = 0; break; case "FloatMat4": paramType = EffectParameterType.Single; paramClass = EffectParameterClass.Matrix; rowCount = 4; colCount = 4; _cachedValue = MonoMac.OpenGL.Matrix4.Identity; break; } if (numOfElements > 1) { // Setup our elements for (int x = 0; x < numOfElements; x++) { EffectParameter ep = new EffectParameter(parent, name, paramIndex, userIndex, uniformLocation, paramType, paramClass, rowCount, colCount, _cachedValue, paramLength); elements._parameters.Add(ep.Name + "[" + x + "]", ep); } } }
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 }); } }
private static EffectParameterCollection ReadParameters(BinaryReader reader) { var collection = new EffectParameterCollection(); var count = (int)reader.ReadByte(); if (count == 0) { return(collection); } for (var i = 0; i < count; i++) { var class_ = (EffectParameterClass)reader.ReadByte(); var type = (EffectParameterType)reader.ReadByte(); var name = reader.ReadString(); var semantic = reader.ReadString(); var annotations = ReadAnnotations(reader); var rowCount = (int)reader.ReadByte(); var columnCount = (int)reader.ReadByte(); var elements = ReadParameters(reader); var structMembers = ReadParameters(reader); object data = null; if (elements.Count == 0 && structMembers.Count == 0) { switch (type) { case EffectParameterType.Bool: case EffectParameterType.Int32: #if DIRECTX // Under DirectX we properly store integers and booleans // in an integer type. // // MojoShader on the otherhand stores everything in float // types which is why this code is disabled under OpenGL. { var buffer = new int[rowCount * columnCount]; for (var j = 0; j < buffer.Length; j++) { buffer[j] = reader.ReadInt32(); } data = buffer; break; } #endif case EffectParameterType.Single: { var buffer = new float[rowCount * columnCount]; for (var j = 0; j < buffer.Length; j++) { buffer[j] = reader.ReadSingle(); } data = buffer; break; } case EffectParameterType.String: throw new NotImplementedException(); } } var param = new EffectParameter( class_, type, name, rowCount, columnCount, semantic, annotations, elements, structMembers, data); collection.Add(param); } return(collection); }
/// <summary> /// Lazily recomputes the world+view+projection matrix and /// fog vector based on the current effect parameter settings. /// </summary> 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) { // Recompute the world+view+projection matrix? if ((dirtyFlags & EffectDirtyFlags.WorldViewProj) != 0) { Matrix worldViewProj; Matrix.Multiply(ref world, ref view, out worldView); Matrix.Multiply(ref worldView, ref projection, out worldViewProj); worldViewProjParam.SetValue(worldViewProj); dirtyFlags &= ~EffectDirtyFlags.WorldViewProj; } if (fogEnabled) { // Recompute the fog vector? if ((dirtyFlags & (EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable)) != 0) { SetFogVector(ref worldView, fogStart, fogEnd, fogVectorParam); dirtyFlags &= ~(EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable); } } else { // When fog is disabled, make sure the fog vector is reset to zero. if ((dirtyFlags & EffectDirtyFlags.FogEnable) != 0) { fogVectorParam.SetValue(Vector4.Zero); dirtyFlags &= ~EffectDirtyFlags.FogEnable; } } return(dirtyFlags); }