private void initializeDeferredShading(IXNAGame _game, int backBufferWidth, int backBufferHeight) { shadowMapRT = new RenderTarget2D(_game.GraphicsDevice, shadowMapSize, shadowMapSize, 1, SurfaceFormat.Single); shadowMapDS = new DepthStencilBuffer(GraphicsDevice, shadowMapSize, shadowMapSize, GraphicsDevice.DepthStencilBuffer.Format); lightRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, 1, SurfaceFormat.HalfVector4, RenderTargetUsage.PreserveContents); deferredFinalRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, 1, SurfaceFormat.HalfVector4, RenderTargetUsage.PreserveContents); directionalLightShader = loadShader("DirectionalLight.fx"); directionalLightShader.SetTechnique("Technique0"); finalCombineEffect = loadShader("CombineFinal.fx"); finalCombineEffect.SetTechnique("Technique1"); pointLightShader = loadShader("PointLight.fx"); pointLightShader.SetTechnique("Technique1"); spotLightShader = loadShader("SpotLight.fx"); spotLightShader.SetTechnique("Technique1"); shadowMapShader = loadShader("ShadowMap.fx"); }
public override void Initialize() { base.Initialize(); bool isDepthStencilAsShaderResourceRequired = RenderSystem.ConfigContext.RenderPassPlugins.Any(plugin => plugin.Value.Tags.Get(RenderTargetKeys.RequireDepthStencilShaderResource)); // By default, the MainPlugin is using the back buffer as the render target RenderTarget = GraphicsDevice.BackBuffer; // Create depth stencil #if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES var depthStencilFormat = PixelFormat.D16_UNorm; #else var depthStencilFormat = PixelFormat.D24_UNorm_S8_UInt; #endif if (GraphicsDevice.DepthStencilBuffer != null) { DepthStencil = GraphicsDevice.DepthStencilBuffer; } else { var depthStencil = Texture.New2D(GraphicsDevice, RenderTarget.Width, RenderTarget.Height, depthStencilFormat, TextureFlags.DepthStencil | (isDepthStencilAsShaderResourceRequired ? TextureFlags.ShaderResource : TextureFlags.None)); DepthStencil = depthStencil.ToDepthStencilBuffer(false); } if (DepthStencilBuffer.IsReadOnlySupported(GraphicsDevice)) { DepthStencilReadOnly = DepthStencil.Texture.ToDepthStencilBuffer(true); } }
public static Texture2D CalculateShadowMapForScene(GraphicsDevice graphicsDevice, RenderTarget2D renderTarget, DepthStencilBuffer depthBuffer, Vector3 lightDirection, BoundingSphere bounds, int SceneId) { DepthStencilBuffer old = SetupShadowMap(graphicsDevice, ref renderTarget, ref depthBuffer); ShaderManager.SetCurrentEffect(ShaderManager.EFFECT_ID.SHADOWMAP); ShaderManager.SetValue("LightProj", CalcLightProjection(bounds, lightDirection, graphicsDevice.Viewport)); ShaderManager.SetValue("LightView", Matrix.CreateLookAt(lightDirection * bounds.Radius + bounds.Center, bounds.Center, Vector3.Up)); foreach (DrawableSceneComponent dsc in ObjectManager.drawableSceneComponents[SceneId]) { if (!dsc.Visible) { continue; } if (dsc is AnimatedModel) { dsc.DrawWithEffect(ShaderManager.EFFECT_ID.SHADOWMAP, "ShadowMapRenderAnimation"); } else { dsc.DrawWithEffect(ShaderManager.EFFECT_ID.SHADOWMAP, "ShadowMapRenderStatic"); } } ResetGraphicsDevice(graphicsDevice, old); return(renderTarget.GetTexture()); }
public void TestDepthStencilBufferWithNativeReadonly() { //// Without shaders, it is difficult to check this method without accessing internals //// Force to create a device var device = GraphicsDevice.New(DeviceCreationFlags.None, GraphicsProfile.Level_11_0); // Check that reaonly is not supported for depth stencil buffer Assert.That(DepthStencilBuffer.IsReadOnlySupported(device), Is.True); // Check texture creation with an array of data, with usage default to later allow SetData var texture = Texture2D.New(device, 256, 256, PixelFormat.D32_Float, TextureFlags.ShaderResource | TextureFlags.DepthStencil); // Creates a new depth stencil buffer var depthStencilBuffer = texture.ToDepthStencilBuffer(true); // Clear the depth stencil buffer with a value of 0.5f, but the depth buffer is readonly device.Clear(depthStencilBuffer, DepthStencilClearOptions.DepthBuffer, 0.5f); var values = texture.GetData <float>(); Assert.That(values.Length, Is.EqualTo(256 * 256)); Assert.That(values[0], Is.EqualTo(0.0f)); // Dispose the depth stencil buffer depthStencilBuffer.Dispose(); device.Dispose(); }
protected void InitializeRendering(GraphicsDevice graphicsDevice) { // Get our initial render target size // The scaling factor doesn't seem to affect the image quality. There is no golden value for this as stated in the SDK documentation var renderTargetSize = HMD.GetDefaultRenderTargetSize(1.5f); // Create the render target texture that is shown on the HMD RenderTarget = RenderTarget2D.New(graphicsDevice, renderTargetSize.Width, renderTargetSize.Height, new MipMapCount(1), PixelFormat.R8G8B8A8.UNorm); // The created texture can have a different size due to hardware limitations so the render target size needs to be updated renderTargetSize.Width = RenderTarget.Width; renderTargetSize.Height = RenderTarget.Height; DepthStencilBuffer = DepthStencilBuffer.New(graphicsDevice, renderTargetSize.Width, renderTargetSize.Height, DepthFormat.Depth32, true); // Compute the virtual cameras' viewports EyeViewport[0] = new Rect(0, 0, renderTargetSize.Width / 2, renderTargetSize.Height); EyeViewport[1] = new Rect((renderTargetSize.Width + 1) / 2, 0, EyeViewport[0].Width, EyeViewport[0].Height); // Create HMD's eye texture data EyeTextureData = new D3D11TextureData[2]; EyeTextureData[0].Header.API = RenderAPIType.D3D11; EyeTextureData[0].Header.TextureSize = renderTargetSize; EyeTextureData[0].Header.RenderViewport = EyeViewport[0]; EyeTextureData[0].pTexture = ((SharpDX.Direct3D11.Texture2D)RenderTarget).NativePointer; EyeTextureData[0].pSRView = ((ShaderResourceView)RenderTarget).NativePointer; // Right eye holds the same values except for the viewport EyeTextureData[1] = EyeTextureData[0]; EyeTextureData[1].Header.RenderViewport = EyeViewport[1]; }
protected override async Task LoadContent() { await base.LoadContent(); var view = Matrix.LookAtRH(new Vector3(2, 2, 2), new Vector3(0, 0, 0), Vector3.UnitY); var projection = Matrix.PerspectiveFovRH((float)Math.PI / 4.0f, (float)GraphicsDevice.BackBuffer.Width / GraphicsDevice.BackBuffer.Height, 0.1f, 100.0f); worldViewProjection = Matrix.Multiply(view, projection); geometry = GeometricPrimitive.Cube.New(GraphicsDevice); simpleEffect = new SimpleEffect(GraphicsDevice) { Texture = UVTexture }; // TODO DisposeBy is not working with device reset offlineTarget0 = Texture2D.New(GraphicsDevice, 512, 512, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget).DisposeBy(this).ToRenderTarget().DisposeBy(this); offlineTarget1 = Texture2D.New(GraphicsDevice, 512, 512, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget).DisposeBy(this).ToRenderTarget().DisposeBy(this); offlineTarget2 = Texture2D.New(GraphicsDevice, 512, 512, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget).DisposeBy(this).ToRenderTarget().DisposeBy(this); depthBuffer = Texture2D.New(GraphicsDevice, 512, 512, PixelFormat.D16_UNorm, TextureFlags.DepthStencil).DisposeBy(this).ToDepthStencilBuffer(false).DisposeBy(this); width = GraphicsDevice.BackBuffer.Width; height = GraphicsDevice.BackBuffer.Height; }
public HolographicGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters, HolographicSpace holographicSpace) : base(device, presentationParameters) { if (GraphicsDevice.RenderTargetViewAllocator.DescriptorHeap.Description.DescriptorCount != BufferCount) { GraphicsDevice.RenderTargetViewAllocator.Dispose(); GraphicsDevice.RenderTargetViewAllocator = new DescriptorAllocator(GraphicsDevice, DescriptorHeapType.RenderTargetView, descriptorCount: BufferCount); } using (IDXGIDevice dxgiDevice = GraphicsDevice.NativeDirect3D11Device.QueryInterface <IDXGIDevice>()) { IDirect3DDevice direct3DInteropDevice = Direct3DInterop.CreateDirect3DDevice(dxgiDevice); HolographicSpace = holographicSpace; HolographicSpace.SetDirect3D11Device(direct3DInteropDevice); } HolographicDisplay = HolographicDisplay.GetDefault(); SpatialStationaryFrameOfReference = HolographicDisplay.SpatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation(); HolographicFrame = HolographicSpace.CreateNextFrame(); HolographicSurface = HolographicFrame.GetRenderingParameters(HolographicFrame.CurrentPrediction.CameraPoses[0]).Direct3D11BackBuffer; HolographicBackBuffer = GetHolographicBackBuffer(); renderTarget = CreateRenderTarget(); direct3D11RenderTarget = CreateDirect3D11RenderTarget(); DepthStencilBuffer.Dispose(); DepthStencilBuffer = CreateDepthStencilBuffer(); }
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); }
private void SetOutputInternal(DepthStencilBuffer depthStencilBuffer, params RenderTarget[] views) { // TODO: Do we want to handle the output the same way we handle the input textures? outputDepthStencilBuffer = depthStencilBuffer; outputRenderTargetView = null; outputRenderTargetViews = views; }
private void SetOutputInternal(RenderTarget view, DepthStencilBuffer depthStencilBuffer) { // TODO: Do we want to handle the output the same way we handle the input textures? outputDepthStencilBuffer = depthStencilBuffer; outputRenderTargetView = view; outputRenderTargetViews = null; }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { if (DepthStencilBuffer != null) { DepthStencilBuffer.Dispose(); } if (RenderTarget != null) { RenderTarget.Dispose(); } if (HMD != null) { HMD.Dispose(); } OVR.Shutdown(); } _disposed = true; }
public override void Initialize() { var device = DeviceService.DirectXDevice; if (outputRule == OutputRule.NewRenderTarget) { renderTarget = ToDispose(RenderTarget2D.New(device, textureDescription)); renderTarget.DebugName = string.Format("RT2D_{0}", Name); var depthStencilDesc = new Texture2DDescription() { ArraySize = 1, MipLevels = 1, BindFlags = BindFlags.DepthStencil, Format = device.DepthStencilBuffer.Format, Width = textureDescription.Width, Height = textureDescription.Height, SampleDescription = textureDescription.SampleDescription, CpuAccessFlags = CpuAccessFlags.None, Usage = ResourceUsage.Default, OptionFlags = ResourceOptionFlags.None }; depthStencil = ToDispose(DepthStencilBuffer.New(device, depthStencilDesc)); } Output = renderTarget; }
internal void SetGraphicsDevice(GraphicsDevice graphics) { //calculate a system wide unique id for the graphics device #if XBOX360 this.graphicsId = 999; #else this.graphicsId = System.Diagnostics.Process.GetCurrentProcess().Id; #endif this.screenFormat = graphics.PresentationParameters.BackBufferFormat; this.depthFormat = graphics.PresentationParameters.EnableAutoDepthStencil ? graphics.PresentationParameters.AutoDepthStencilFormat : DepthFormat.Unknown; screenMultisample = graphics.PresentationParameters.MultiSampleType; if (graphics != this.graphics) { graphicsIndex++; } this.graphicsId ^= graphicsIndex << 16; this.graphicsId ^= (int)(DateTime.Now.Ticks & 0xFFFF); //directly accessing graphics.DepthStencilBuffer will memory leak.. so it's only used here this.defaultDepthStencil = graphics.DepthStencilBuffer; this.initalised = true; this.graphics = graphics; this.windowWidth = graphics.PresentationParameters.BackBufferWidth; this.windowHeight = graphics.PresentationParameters.BackBufferHeight; }
public void Draw(GameTime gameTime) { ICamera cameraBackup = game.Renderer.Camera; game.Renderer.Camera = scene.Camera; game.Graphics.Device.SetRenderTarget(0, renderTarget); DepthStencilBuffer depthStencilBufferBackup = game.Graphics.Device.DepthStencilBuffer; if (depthStencilBuffer != null) { game.Graphics.Device.DepthStencilBuffer = depthStencilBuffer; } game.Graphics.Device.Clear(ClearOptions.DepthBuffer, Color.White, 1.0f, 0); OnDrawBegin(); scene.Draw(gameTime); OnDrawEnd(); if (depthStencilBuffer != null) { game.Graphics.Device.DepthStencilBuffer = depthStencilBufferBackup; } game.Graphics.Device.SetRenderTarget(0, null); game.Renderer.Camera = cameraBackup; renderedAtLeastOnce = true; }
public void Shutdown() { DepthStencilView?.Dispose(); DepthStencilView = null; DepthStencilBuffer?.Dispose(); DepthStencilBuffer = null; for (int i = 0; i < BUFFER_COUNT; i++) { ShaderResourceViewArray[i]?.Dispose(); ShaderResourceViewArray[i] = null; } ShaderResourceViewArray = null; for (int i = 0; i < BUFFER_COUNT; i++) { RenderTargetViewArray[i]?.Dispose(); RenderTargetViewArray[i] = null; } RenderTargetViewArray = null; for (int i = 0; i < BUFFER_COUNT; i++) { RenderTargetTexture2DArray[i]?.Dispose(); RenderTargetTexture2DArray[i] = null; } RenderTargetTexture2DArray = null; }
public RenderTarget2DAdapter(ICanyonShooterGame game, int width, int height, int numberLevels, SurfaceFormat format, RenderTargetUsage usage, DepthFormat depthFormat) { this.game = game; CreateRenderTarget(format, width, height, numberLevels, usage); depthStencilBuffer = new DepthStencilBuffer(game.Graphics.Device, width, height, depthFormat, MultiSampleType.None, 0); }
public void ShutDown() { SwapChain?.SetFullscreenState(false, null); AlphaEnableBlendingState?.Dispose(); AlphaEnableBlendingState = null; AlphaDisableBlendingState?.Dispose(); AlphaDisableBlendingState = null; DepthDisabledStencilState?.Dispose(); DepthDisabledStencilState = null; RasterState?.Dispose(); RasterState = null; RasterStateNoCulling?.Dispose(); RasterStateNoCulling = null; RasterStateWirefram?.Dispose(); RasterStateWirefram = null; DepthStencilView?.Dispose(); DepthStencilView = null; DepthStencilState?.Dispose(); DepthStencilState = null; DepthStencilBuffer?.Dispose(); DepthStencilBuffer = null; RenderTargetView?.Dispose(); RenderTargetView = null; DeviceContext?.Dispose(); DeviceContext = null; Device?.Dispose(); Device = null; SwapChain?.Dispose(); SwapChain = null; }
public void Render(GraphicsDevice gd) { DepthStencilBuffer buff = gd.DepthStencilBuffer; gd.DepthStencilBuffer = null; UpdatePartcles(gd); gd.DepthStencilBuffer = buff; _renderEffect.Parameters["View"].SetValue(Matrix.Identity); _renderEffect.Parameters["Projection"].SetValue(_proj); _renderEffect.Parameters["World"].SetValue(Matrix.Identity); _renderEffect.Parameters["PositionsTexture"].SetValue(_positions[_currentTargetIn].GetTexture()); _renderEffect.Parameters["ParticleSize"].SetValue(2); gd.VertexDeclaration = _dec; _renderEffect.Begin(); gd.RenderState.AlphaBlendEnable = true; //gd.Clear(Color.Black); foreach (EffectPass pass in _renderEffect.CurrentTechnique.Passes) { pass.Begin(); gd.Textures[0] = _particleTexture; gd.DrawUserPrimitives(PrimitiveType.PointList, _verts, 0, _maxParticles); pass.End(); } _renderEffect.End(); int tmp = _currentTargetOut; _currentTargetOut = _currentTargetIn; _currentTargetIn = tmp; }
/// <summary> /// Draws the gameplay scene. /// </summary> private void DrawGameplayScene() { // Render explosions to texture if (renderTarget != null && stampSpriteList.Count > 0) { device.SetRenderTarget(0, renderTarget); DepthStencilBuffer old = device.DepthStencilBuffer; device.DepthStencilBuffer = depthStencilBuffer; spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Deferred, SaveStateMode.None); DrawTerrain(Model.TerrainTexture); foreach (StampSprite e in stampSpriteList) { spriteBatch.Draw(e.Texture, e.Position, Color.White); } stampSpriteList.Clear(); spriteBatch.End(); device.SetRenderTarget(0, null); device.DepthStencilBuffer = old; Model.TerrainTexture = renderTarget.GetTexture(); } device.Clear(backgroundColor); /* Draw background image */ Rectangle screenRect = new Rectangle(0, 0, device.PresentationParameters.BackBufferWidth, device.PresentationParameters.BackBufferHeight); spriteBatch.Begin(); spriteBatch.Draw(Model.BackGround, screenRect, Color.White); spriteBatch.End(); /* Draw terrain, entities and lines */ spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.None, Camera.Transform); DrawTerrain(Model.TerrainTexture); DrawEntities(Model.EntityList); DrawPlayerInfo(Model.PlayerList); DrawLines(); spriteBatch.End(); spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.None); DrawScores(Model.PlayerList); if (Model.GameOver) { //Draw end game and win notice Color color = ColorFromPlayerIndex(Model.GetWinner()); string gameOver = "Game Over! Player " + Model.GetWinner() + " wins!"; string quit = "Press ESC to go back to the menu."; Vector2 gameOverSize = Sprites.MenuRegularFont.MeasureString(gameOver); Vector2 quitSize = Sprites.MenuRegularFont.MeasureString(quit); spriteBatch.DrawString(Sprites.MenuRegularFont, gameOver, Camera.Position - new Vector2(gameOverSize.X / 2, gameOverSize.Y), color); spriteBatch.DrawString(Sprites.MenuRegularFont, quit, Camera.Position - new Vector2(quitSize.X / 2, 0), color); } spriteBatch.End(); /* Update camera */ UpdateCamera(); }
private void GenerateExplosionMap() { GraphicsDevice gd = GraphicsDevice; DepthStencilBuffer dsb = gd.DepthStencilBuffer; gd.DepthStencilBuffer = null; gd.SetRenderTarget(0, _explosionMaps[_currentTargetOut]); SpriteBatch batch = PrimalDevistation.Instance.Batch; batch.Begin(); batch.Draw(_explosionMaps[_currentTargetIn].GetTexture(), new Rectangle(0, 0, (int)_size.X, (int)_size.Y), Color.White); batch.End(); batch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState); Vector2 cam = PrimalDevistation.Instance.Camera.Position; for (int i = 0; i < _explosions.Count; i++) { int size = (int)(_explosions[i].Z); int hSize = size / 2; Texture2D tex = _explosionTextures[size]; batch.Draw(tex, new Rectangle((int)(_explosions[i].X - hSize), (int)(_explosions[i].Y - hSize), size, size), Color.White); } batch.End(); gd.SetRenderTarget(0, null); gd.DepthStencilBuffer = dsb; _explosions.Clear(); int tmp = _currentTargetOut; _currentTargetOut = _currentTargetIn; _currentTargetIn = tmp; }
public void Begin(int backBufferWidth, int backBufferHeight, SurfaceFormat bufferFormat, MultiSampleType multiSampleType) { if (renderTarget == null || renderTargetWidth != backBufferWidth || renderTargetHeight != backBufferHeight) { if (renderTarget != null) { renderTarget.Dispose(); depthBuffer.Dispose(); } renderTarget = new RenderTarget2D(graphicsDevice, backBufferWidth, backBufferHeight, 1, bufferFormat, multiSampleType, 0); depthBuffer = new DepthStencilBuffer(graphicsDevice, backBufferWidth, backBufferHeight, graphicsDevice.DepthStencilBuffer.Format, multiSampleType, 0); renderTargetWidth = backBufferWidth; renderTargetHeight = backBufferHeight; } graphicsDevice.SetRenderTarget(0, renderTarget); savedDepthBuffer = graphicsDevice.DepthStencilBuffer; graphicsDevice.DepthStencilBuffer = depthBuffer; }
protected virtual void CreateBuffers() { if (_buffersCreated) { return; } var width = _targetSize.Width; var height = _targetSize.Height; /* * Note that the front buffer doesn't need any multisampling/antialiasing (AA) * because all rendering is done to the back buffer, which is then copied to * the front buffer. This works out well because D3DImage can only use AA with * an IDirect3DDevice9Ex, and XNA only supports IDirect3DDevice9. */ var device = Graphics.GraphicsDevice; if (device == null) { return; } _frontBuffer = new RenderTarget2D( device, width, height, 1, device.PresentationParameters.BackBufferFormat, MultiSampleType.None, 0); _backBuffer = new RenderTarget2D( device, width, height, 1, device.PresentationParameters.BackBufferFormat, device.PresentationParameters.MultiSampleType, device.PresentationParameters.MultiSampleQuality); _frontBufferPointer = GetRenderTargetPointer(_frontBuffer); if (GraphicsOptions.EnableDepthStencil) { _depthStencilBuffer = new DepthStencilBuffer( device, width, height, device.DepthStencilBuffer.Format, device.DepthStencilBuffer.MultiSampleType, device.DepthStencilBuffer.MultiSampleQuality); _deviceDepthStencilBuffer = device.DepthStencilBuffer; device.DepthStencilBuffer = _depthStencilBuffer; } _buffersCreated = true; }
public void ShutDown() { // Before shutting down set to windowed mode or when you release the swap chain it will throw an exception. SwapChain?.SetFullscreenState(false, null); // Dispose of all objects. DepthDisabledStencilState?.Dispose(); DepthDisabledStencilState = null; RasterState?.Dispose(); RasterState = null; DepthStencilView?.Dispose(); DepthStencilView = null; DepthStencilState?.Dispose(); DepthStencilState = null; DepthStencilBuffer?.Dispose(); DepthStencilBuffer = null; RenderTargetView?.Dispose(); RenderTargetView = null; DeviceContext?.Dispose(); DeviceContext = null; Device?.Dispose(); Device = null; SwapChain?.Dispose(); SwapChain = null; }
public RenderTargetState(GraphicsDevice GraphicsDevice, int renderTargetIndex) { this.GraphicsDevice = GraphicsDevice; RenderTarget = (RenderTarget2D)GraphicsDevice.GetRenderTarget(renderTargetIndex); DepthBuffer = GraphicsDevice.DepthStencilBuffer; CreatedBuffers = false; }
/// <summary> /// Event handler called when the graphics device is reset /// </summary> /// <param name="sender">unused</param> /// <param name="e">unused</param> private void CreateDepthBuffer(object sender, EventArgs e) { int bbw = mGraphics.GraphicsDevice.PresentationParameters.BackBufferWidth; int bbh = mGraphics.GraphicsDevice.PresentationParameters.BackBufferHeight; mDepthBuffer = new DepthStencilBuffer(mGraphics.GraphicsDevice, bbw, bbh, mGraphics.GraphicsDevice.DepthStencilBuffer.Format); }
/// <summary> /// Sets the render target outputs. /// </summary> /// <param name="depthStencilBuffer">The depth stencil buffer.</param> /// <param name="views">The render target output views.</param> /// <returns>PostEffectBase.</returns> /// <exception cref="System.ArgumentNullException">views</exception> public void SetOutput(DepthStencilBuffer depthStencilBuffer, params RenderTarget[] views) { if (views == null) { throw new ArgumentNullException("views"); } SetOutputInternal(depthStencilBuffer, views); }
/// <summary> /// This is where it all happens. Grabs a scene that has already been rendered, /// and uses postprocess magic to add a glowing bloom effect over the top of it. /// </summary> public override void Draw(GameTime gameTime) { DepthStencilBuffer oldBuffer = GraphicsDevice.DepthStencilBuffer; GraphicsDevice.DepthStencilBuffer = null; // Resolve the scene into a texture, so we can // use it as input data for the bloom processing. GraphicsDevice.ResolveBackBuffer(resolveTarget); // Pass 1: draw the scene into rendertarget 1, using a // shader that extracts only the brightest parts of the image. bloomExtractEffect.Parameters["BloomThreshold"].SetValue( Settings.BloomThreshold); DrawFullscreenQuad(resolveTarget, renderTarget1, bloomExtractEffect, IntermediateBuffer.PreBloom); // Pass 2: draw from rendertarget 1 into rendertarget 2, // using a shader to apply a horizontal gaussian blur filter. SetBlurEffectParameters(1.0f / (float)renderTarget1.Width, 0); DrawFullscreenQuad(renderTarget1.GetTexture(), renderTarget2, gaussianBlurEffect, IntermediateBuffer.BlurredHorizontally); // Pass 3: draw from rendertarget 2 back into rendertarget 1, // using a shader to apply a vertical gaussian blur filter. SetBlurEffectParameters(0, 1.0f / (float)renderTarget1.Height); DrawFullscreenQuad(renderTarget2.GetTexture(), renderTarget1, gaussianBlurEffect, IntermediateBuffer.BlurredBothWays); // Pass 4: draw both rendertarget 1 and the original scene // image back into the main backbuffer, using a shader that // combines them to produce the final bloomed result. GraphicsDevice.SetRenderTarget(0, null); EffectParameterCollection parameters = bloomCombineEffect.Parameters; parameters["BloomIntensity"].SetValue(Settings.BloomIntensity); parameters["BaseIntensity"].SetValue(Settings.BaseIntensity); parameters["BloomSaturation"].SetValue(Settings.BloomSaturation); parameters["BaseSaturation"].SetValue(Settings.BaseSaturation); GraphicsDevice.Textures[1] = resolveTarget; Viewport viewport = GraphicsDevice.Viewport; DrawFullscreenQuad(renderTarget1.GetTexture(), viewport.Width, viewport.Height, bloomCombineEffect, IntermediateBuffer.FinalResult); GraphicsDevice.DepthStencilBuffer = oldBuffer; }
/** * DrawableGameComponent */ public override void LoadContent() { heightmap = ResourceMgr.Instance.Game.Content.Load <Texture2D>("Ice/height_map"); buildGeometry(); vertex_buffer = new VertexBuffer(ResourceMgr.Instance.Game.GraphicsDevice, VertexCount * VertexData.SizeInBytes, BufferUsage.WriteOnly); vertex_buffer.SetData(vertex_data); index_buffer = new IndexBuffer(ResourceMgr.Instance.Game.GraphicsDevice, typeof(short), IndexCount, BufferUsage.WriteOnly); index_buffer.SetData(vertex_indices); vertex_declaration = new VertexDeclaration(ResourceMgr.Instance.Game.GraphicsDevice, VertexData.VertexElements); particle_vertex_declaration = new VertexDeclaration(ResourceMgr.Instance.Game.GraphicsDevice, ParticleData.VertexElements); effect = ResourceMgr.Instance.Game.Content.Load <Effect>("Ice/Ice"); effect.Parameters["low_color"].SetValue(low_color); effect.Parameters["high_color"].SetValue(high_color); effect.Parameters["height_scale"].SetValue(height_scale); temporaryRT = new RenderTarget2D(ResourceMgr.Instance.Game.GraphicsDevice, particle_count, particle_count, 1, SurfaceFormat.Vector4, ResourceMgr.Instance.Game.GraphicsDevice.PresentationParameters.MultiSampleType, 0); positionRT = new RenderTarget2D(ResourceMgr.Instance.Game.GraphicsDevice, particle_count, particle_count, 1, SurfaceFormat.Vector4, ResourceMgr.Instance.Game.GraphicsDevice.PresentationParameters.MultiSampleType, 0); velocityRT = new RenderTarget2D(ResourceMgr.Instance.Game.GraphicsDevice, particle_count, particle_count, 1, SurfaceFormat.Vector4, ResourceMgr.Instance.Game.GraphicsDevice.PresentationParameters.MultiSampleType, 0); simulationDepthBuffer = new DepthStencilBuffer(ResourceMgr.Instance.Game.GraphicsDevice, particle_count, particle_count, ResourceMgr.Instance.Game.GraphicsDevice.DepthStencilBuffer.Format, ResourceMgr.Instance.Game.GraphicsDevice.PresentationParameters.MultiSampleType, 0); spriteBatch = new SpriteBatch(ResourceMgr.Instance.Game.GraphicsDevice); physics_effect = ResourceMgr.Instance.Game.Content.Load <Effect>("Ice/SnowPhysics"); physics_effect.Parameters["windStrength"].SetValue(1.0f * 5.0f); physics_effect.Parameters["windDirection"].SetValue(new Vector4(-0.5f, -2.0f, 0.1f, 0.0f)); Random rand = new Random(); random_texture = new Texture2D(ResourceMgr.Instance.Game.GraphicsDevice, particle_count, particle_count, 1, TextureUsage.None, SurfaceFormat.Vector4); Vector4[] pointsarray = new Vector4[particle_count * particle_count]; for (int i = 0; i < particle_count * particle_count; i++) { pointsarray[i] = new Vector4(); pointsarray[i].X = (float)rand.NextDouble() - 0.5f; pointsarray[i].Y = (float)rand.NextDouble() - 0.5f; pointsarray[i].Z = (float)rand.NextDouble() - 0.5f; pointsarray[i].W = (float)rand.NextDouble() - 0.5f; } random_texture.SetData <Vector4>(pointsarray); snow_effect = ResourceMgr.Instance.Game.Content.Load <Effect>("Ice/SnowPointSprite"); snow_effect.Parameters["sprite_map"].SetValue(ResourceMgr.Instance.Game.Content.Load <Texture2D>("Ice/snow")); reset_physics = true; base.LoadContent(); }
/// <summary> /// Creates full view render targets on demand. /// </summary> public void CreateFullViewRenderTarget() { // TODO: check previous status to dispose the rendertarget? if (textureCube != null) { RenderTarget = textureCube.ToRenderTarget(ViewType.Full, 0, 0); DepthStencil = Texture2D.New(textureCube.GraphicsDevice, Size, Size, PixelFormat.D24_UNorm_S8_UInt, TextureFlags.DepthStencil, 6).ToDepthStencilBuffer(false); } }
/// <summary> /// Sets the render target output. /// </summary> /// <param name="view">The render target output view.</param> /// <param name="depthStencilBuffer">The depth stencil buffer.</param> /// <exception cref="System.ArgumentNullException">view</exception> public void SetOutput(RenderTarget view, DepthStencilBuffer depthStencilBuffer = null) { if (view == null) { throw new ArgumentNullException("view"); } SetOutputInternal(view, depthStencilBuffer); }