/// <summary> /// /// </summary> public override void Initialize() { skyCube = new RenderTargetCube(device, ColorFormat.Rgba16F, 128, true); skyConstsCB = new ConstantBuffer(device, typeof(SkyConsts)); LoadContent(); Game.Reloading += (s, e) => LoadContent(); var skySphere = SkySphere.GetVertices(4).Select(v => new SkyVertex { Vertex = v }).ToArray(); skyVB = new VertexBuffer(Game.GraphicsDevice, typeof(SkyVertex), skySphere.Length); skyVB.SetData(skySphere); randVectors = new Vector3[64]; for (int i = 0; i < randVectors.Length; i++) { Vector3 randV; do { randV = rand.NextVector3(-Vector3.One, Vector3.One); } while (randV.Length() > 1 && randV.Y < 0); randVectors[i] = randV.Normalized(); } }
public static void DrawSphere(Matrix World, Camera3D camera, RenderTargetCube Cube) { CubeEffectHolder.SetFromCamera(camera); CubeEffectHolder.SetWorld(World); CubeEffectHolder.MyEffect.Parameters["ShadowReference"].SetValue(Cube); Render.DrawModel(CubeModel, CubeEffectHolder.MyEffect); }
private void GenerateTargetMips() { for (int i = 0; i < _targetsToMipMapCount; i++) { RenderTargetBinding binding = _targetsToMipMap[i]; //Gen cube mips if (binding.IsRenderTargetCube) { RenderTargetCube rcube = binding.RenderTargetCube; D3D10Helper.CheckDisposed(rcube); if (rcube.MipCount > 1) { D3D10TextureCubeImplementation impl = rcube.Implementation as D3D10TextureCubeImplementation; _graphicsDevice.GenerateMips(impl.D3D10ShaderResourceView); } //Gen 2D tex mips } else { RenderTarget2D r2d = binding.RenderTarget2D; D3D10Helper.CheckDisposed(r2d); if (r2d.MipCount > 1) { D3D10Texture2DImplementation impl = r2d.Implementation as D3D10Texture2DImplementation; _graphicsDevice.GenerateMips(impl.D3D10ShaderResourceView); } } } }
public void ShouldClearRenderTargetAndGetData(int size) { var dataSize = size * size; var renderTargetCube = new RenderTargetCube(gd, size, false, SurfaceFormat.Color, DepthFormat.Depth16); var colors = new[] { Color.BlanchedAlmond, Color.BlueViolet, Color.DarkSeaGreen, Color.ForestGreen, Color.IndianRed, Color.LightGoldenrodYellow }; for (var i = 0; i < 6; i++) { gd.SetRenderTarget(renderTargetCube, (CubeMapFace)i); gd.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, colors[i], 1.0f, 0); gd.SetRenderTarget(null, (CubeMapFace)i); } for (var i = 0; i < 6; i++) { var readData = new Color[dataSize]; renderTargetCube.GetData((CubeMapFace)i, readData); for (var j = 0; j < dataSize; j++) { Assert.AreEqual(colors[i], readData[j]); } } renderTargetCube.Dispose(); }
private void PathChange() { RenderTargetCube tc = new RenderTargetCube(Game1.graphicsDevice, Math.Max(64, (int)Resolution.get()), false, SurfaceFormat.Color, DepthFormat.None); { for (int i = 0; i < 6; i++) { CubeMapFace face = (CubeMapFace)i; SkyFaceTexture = AssetManager.Load <Texture2D>(this.GetParent().TextureDirectory.get() + Path.get() + face.ToString().Substring(0, 3).ToLower() + face.ToString().Last().ToString().ToUpper()); Game1.graphicsDevice.SetRenderTarget(tc, face); Game1.graphicsDevice.Clear(Color.Black); Game1.graphicsDevice.Textures[0] = SkyFaceTexture; Deferred3DScene.PasteEffect.CurrentTechnique.Passes[0].Apply(); FullscreenQuad.Draw(); } } Game1.graphicsDevice.SetRenderTarget(null); Game1.graphicsDevice.Clear(Color.Transparent); if (MyCube.get() != null) { MyCube.get().Dispose(); } MyCube.set(tc); }
/// <summary> /// Releases a render target and puts it back into the pool for future reuse. /// </summary> /// <param name="renderTarget">The render target.</param> public void Recycle(RenderTargetCube renderTarget) { if (renderTarget == null || renderTarget.IsDisposed) { return; } if (Enabled) { if ((GlobalSettings.ValidationLevelInternal & GlobalSettings.ValidationLevelUserHighExpensive) != 0) { if (RenderTargetsCube.Contains(renderTarget)) { throw new InvalidOperationException("Cannot recycle render target because it is already in the render target pool."); } } RenderTargetsCube.Add(renderTarget); CountersCube.Add(0); } else { renderTarget.Dispose(); } }
private void DrawCubeFace(Light light, RenderTargetCube cube, CubeMapFace cubeMapFace, GameTime gameTime) { Vector3 position = lightService.Position + light.Position; Vector3 forward = Vector3.Zero; Vector3 up = Vector3.Up; // Rendertarget auf eine Seite des Shadow Cubes setzen GraphicsDevice.SetRenderTarget(cube, cubeMapFace); GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.White, 1.0f, 0); switch (cubeMapFace) { case CubeMapFace.PositiveX: forward = Vector3.Right; break; case CubeMapFace.NegativeX: forward = Vector3.Left; break; case CubeMapFace.PositiveY: forward = Vector3.Up; up = Vector3.Backward; break; case CubeMapFace.NegativeY: forward = Vector3.Down; up = Vector3.Forward; break; case CubeMapFace.PositiveZ: forward = Vector3.Forward; break; case CubeMapFace.NegativeZ: forward = Vector3.Backward; break; } shadowEffect.LightPosition = position; shadowEffect.View = Matrix.CreateLookAt(position, position + forward, up); shadowEffect.CurrentTechnique.Passes[0].Apply(); // Objekt auf den Shadow Cube rendern shape.Draw(gameTime); }
public void ContentLostResources() { // https://blogs.msdn.microsoft.com/shawnhar/2007/12/12/virtualizing-the-graphicsdevice-in-xna-game-studio-2-0/ var rt = new RenderTarget2D(gdm.GraphicsDevice, 5, 5); var vb = new DynamicVertexBuffer(gd, VertexPositionColor.VertexDeclaration, 1, BufferUsage.None); var ib = new DynamicIndexBuffer(gd, IndexElementSize.SixteenBits, 1, BufferUsage.None); var rtc = new RenderTargetCube(gd, 1, false, SurfaceFormat.Color, DepthFormat.Depth16); gd.Reset(); Assert.IsTrue(rt.IsContentLost); Assert.IsFalse(rt.IsDisposed); Assert.IsTrue(vb.IsContentLost); Assert.IsFalse(vb.IsDisposed); Assert.IsTrue(ib.IsContentLost); Assert.IsFalse(ib.IsDisposed); Assert.IsTrue(rtc.IsContentLost); Assert.IsFalse(rtc.IsDisposed); rt.Dispose(); vb.Dispose(); ib.Dispose(); rtc.Dispose(); }
public void CleanUp(PloobsEngine.Engine.GraphicFactory factory) { ForwardEnvironmentShader.Cleanup(factory); if (RenderTargetCube != null && !RenderTargetCube.IsDisposed) { RenderTargetCube.Dispose(); } }
public void NullDeviceShouldThrowArgumentNullException() { Assert.Throws <ArgumentNullException>(() => { var renderTarget = new RenderTargetCube(null, 16, false, SurfaceFormat.Color, DepthFormat.None); renderTarget.Dispose(); }); GC.GetTotalMemory(true); // collect uninitialized renderTarget }
public void Dispose() { if (shadowMap != null) { shadowMap.Dispose(); } mo = null; shadowMap = null; }
public RenderTargetCube DrawGaussianBlur(RenderTargetCube renderTargetOutput, CubeMapFace cubeFace, FullScreenTriangle triangle) { //select rendertarget RenderTarget2D renderTargetBlur = null; if (renderTargetOutput.Format != SurfaceFormat.Vector2) { throw new NotImplementedException("Unsupported Format for blurring"); } //Only square expected int size = renderTargetOutput.Size; switch (size) { case 256: renderTargetBlur = _rt2562; break; case 512: renderTargetBlur = _rt5122; break; case 1024: renderTargetBlur = _rt10242; break; case 2048: renderTargetBlur = _rt20482; break; } if (renderTargetBlur == null) { throw new NotImplementedException("Unsupported Size for blurring"); } _graphicsDevice.SetRenderTarget(renderTargetBlur); Vector2 invRes = new Vector2(1.0f / size, 1.0f / size); Shaders.GaussianBlurEffectParameter_InverseResolution.SetValue(invRes); Shaders.GaussianBlurEffectParameter_TargetMap.SetValue(renderTargetOutput); _horizontalPass.Apply(); triangle.Draw(_graphicsDevice); _graphicsDevice.SetRenderTarget(renderTargetOutput, cubeFace); Shaders.GaussianBlurEffectParameter_TargetMap.SetValue(renderTargetBlur); _verticalPass.Apply(); triangle.Draw(_graphicsDevice); return(renderTargetOutput); }
/// <summary> /// Sets a Cube render target, to the first render target slot /// and unbinds all currently bound targets. /// Setting this to null unbinds all targets and sets the target to the currently active /// swap chain's back buffer. /// </summary> /// <param name="renderTarget">Render target to bind</param> /// <param name="cubeMapFace">Which face of the cube map to bind</param> public override void SetRenderTarget(RenderTargetCube renderTarget, CubeMapFace cubeMapFace) { if (renderTarget == null) { _renderTargetManager.SetRenderTargets(null); } else { _tempTarget[0] = new RenderTargetBinding(renderTarget, cubeMapFace); _renderTargetManager.SetRenderTargets(_tempTarget); } }
/// <summary> /// Obtains a cube map render target that matches the given specification. /// </summary> /// <param name="format"> /// The render target format. If a property in the format is <see langword="null"/>, then the /// value of the back buffer is used. The <see cref="RenderTargetFormat.Width"/> is used to /// define the size of the cube map. <see cref="RenderTargetFormat.Height"/> is ignored. /// </param> /// <returns>A cube map render target with the specified format.</returns> /// <remarks> /// This method returns a render target from the pool. If no suitable, free render target is /// found, a new one is created. /// </remarks> public RenderTargetCube ObtainCube(RenderTargetFormat format) { RenderTargetCube renderTarget = null; var pp = GraphicsService.GraphicsDevice.PresentationParameters; int size = format.Width ?? pp.BackBufferWidth; bool mipmap = format.Mipmap ?? false; var surfaceFormat = format.SurfaceFormat ?? pp.BackBufferFormat; var depthStencilFormat = format.DepthStencilFormat ?? pp.DepthStencilFormat; int multiSampleCount = format.MultiSampleCount ?? pp.MultiSampleCount; var renderTargetUsage = format.RenderTargetUsage ?? RenderTargetUsage.DiscardContents; if (Enabled) { int numberOfItems = RenderTargetsCube.Count; int index; for (index = numberOfItems - 1; index >= 0; index--) { var candidate = RenderTargetsCube[index]; if (candidate.Size == size && (candidate.LevelCount > 1) == mipmap && candidate.Format == surfaceFormat && candidate.DepthStencilFormat == depthStencilFormat && candidate.MultiSampleCount == multiSampleCount && candidate.RenderTargetUsage == renderTargetUsage) { renderTarget = candidate; break; } } if (renderTarget != null) { numberOfItems--; if (index < numberOfItems) { RenderTargetsCube[index] = RenderTargetsCube[numberOfItems]; CountersCube[index] = CountersCube[numberOfItems]; } RenderTargetsCube.RemoveAt(numberOfItems); CountersCube.RemoveAt(numberOfItems); return(renderTarget); } } renderTarget = new RenderTargetCube(GraphicsService.GraphicsDevice, size, mipmap, surfaceFormat, depthStencilFormat, multiSampleCount, renderTargetUsage); return(renderTarget); }
public void Load(Game1 game) { if (false) { ShadowCube = new RenderTargetCube(game.GraphicsDevice, 128, false, SurfaceFormat.Bgr565, DepthFormat.Depth24); } IsDynamic = true; // ShadowPlane = new RenderTarget2D(game.GraphicsDevice, 512, 512); Cube = ShadowCube; for (int i = 0; i < 6; i++) { if (i == 3) { game.GraphicsDevice.SetRenderTarget(ShadowCube, CubeMapFace.NegativeX); } if (i == 4) { game.GraphicsDevice.SetRenderTarget(ShadowCube, CubeMapFace.NegativeY); } if (i == 5) { game.GraphicsDevice.SetRenderTarget(ShadowCube, CubeMapFace.NegativeZ); } if (i == 0) { game.GraphicsDevice.SetRenderTarget(ShadowCube, CubeMapFace.PositiveX); } if (i == 1) { game.GraphicsDevice.SetRenderTarget(ShadowCube, CubeMapFace.PositiveY); } if (i == 2) { game.GraphicsDevice.SetRenderTarget(ShadowCube, CubeMapFace.PositiveZ); } game.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.White); } game.GraphicsDevice.SetRenderTarget(null); }
protected override void Initialize() { Robot = new Robot(); Robot.Initialize(Content); InitializeEffects(); Camera = new Camera(Graphics.GraphicsDevice); RasterizerState rasterizerState = new RasterizerState(); rasterizerState.CullMode = CullMode.None; GraphicsDevice.RasterizerState = rasterizerState; //SetSamplerState(); LightPosition[0] = new Vector3(10, 10, -25); LightPosition[1] = new Vector3(8, 10, 25); LightPosition[2] = new Vector3(45, -5, 0); LightPosition[3] = new Vector3(-45, 0, -15); LightColor[0] = new Vector3(1f, 1, 1f); LightColor[1] = new Vector3(1f, 1, 1f); LightColor[2] = new Vector3(1f, 1f, 1f); LightColor[3] = new Vector3(1.0f, 1.0f, 1.0f); LightDirectionSpot[0] = new Vector3(0, -1f, 0); LightDirectionSpot[1] = new Vector3(0, -1f, 0); LightDirectionSpot[2] = new Vector3(0, -1f, 0); LightDirectionSpot[3] = new Vector3(0, -1f, 0); RenderTarget = new RenderTarget2D( GraphicsDevice, GraphicsDevice.PresentationParameters.BackBufferWidth, GraphicsDevice.PresentationParameters.BackBufferHeight, false, GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.Depth24); // RefCubeMap = new RenderTargetCube(this.GraphicsDevice, 256, 1, SurfaceFormat.Color); RefCubeMap = new RenderTargetCube(this.GraphicsDevice, 256, true, SurfaceFormat.Color, DepthFormat.Depth16, 1, RenderTargetUsage.PreserveContents); base.Initialize(); }
/// <summary> /// /// </summary> /// <param name="dst"></param> /// <param name="cubeSrc"></param> /// <param name="sampleCount"></param> public void PrefilterEnvMap(RenderTargetCube envMap) { SetDefaultRenderStates(); int width = envMap.Width / 2; int height = envMap.Height / 2; using (new PixEvent("PrefilterEnvMap")) { var sides = new[] { ShaderFlags.PREFILTER_ENVMAP | ShaderFlags.POSX, ShaderFlags.PREFILTER_ENVMAP | ShaderFlags.NEGX, ShaderFlags.PREFILTER_ENVMAP | ShaderFlags.POSY, ShaderFlags.PREFILTER_ENVMAP | ShaderFlags.NEGY, ShaderFlags.PREFILTER_ENVMAP | ShaderFlags.POSZ, ShaderFlags.PREFILTER_ENVMAP | ShaderFlags.NEGZ }; // loop through mip levels from second to last specular mip level : for (int mip = 1; mip < RenderSystem.EnvMapSpecularMipCount; mip++) { float roughness = (float)mip / (float)(RenderSystem.EnvMapSpecularMipCount - 1); float step = 1.0f / width; vectorCB.SetData(new Vector4(roughness, step, 0, 0)); for (int face = 0; face < 6; face++) { device.SetTargets(null, envMap.GetSurface(mip, (CubeFace)face)); device.SetViewport(0, 0, width, height); device.PixelShaderConstants[0] = vectorCB; device.PipelineState = factory[(int)sides[face]]; device.VertexShaderResources[0] = envMap.GetCubeShaderResource(mip - 1); device.PixelShaderResources[0] = envMap.GetCubeShaderResource(mip - 1); device.PixelShaderSamplers[0] = SamplerState.LinearWrap; device.VertexShaderConstants[0] = matrixCB; device.Draw(3, 0); } width /= 2; height /= 2; } } device.ResetStates(); }
public void Load(Game1 game) { ShadowCube = new RenderTargetCube(game.GraphicsDevice, 256, false, SurfaceFormat.Bgr565, DepthFormat.Depth24); ShadowCube2 = new RenderTargetCube(game.GraphicsDevice, 256, false, SurfaceFormat.Bgr565, DepthFormat.Depth24); //ShadowPlane = new RenderTarget2D(game.GraphicsDevice, 512, 512); Cube = ShadowCube2; //Plane = ShadowPlane; }
internal static bool SameTargetSize(Texture a, Texture b) { int aFormatSize = FormatSize(a.Format); int bFormatSize = FormatSize(b.Format); int aWidth = 0; int aHeight = 0; int bWidth = 0; int bHeight = 0; int aSampleCount = 0; int bSampleCount = 0; if (a is RenderTarget2D) { RenderTarget2D a2d = a as RenderTarget2D; aWidth = a2d.Width; aHeight = a2d.Height; aSampleCount = a2d.MultiSampleCount; } else if (a is RenderTargetCube) { RenderTargetCube acube = a as RenderTargetCube; aWidth = acube.Size; aHeight = acube.Size; aSampleCount = acube.MultiSampleCount; } if (b is RenderTarget2D) { RenderTarget2D b2d = b as RenderTarget2D; bWidth = b2d.Width; bHeight = b2d.Height; bSampleCount = b2d.MultiSampleCount; } else if (b is RenderTargetCube) { RenderTargetCube bcube = b as RenderTargetCube; bWidth = bcube.Size; bHeight = bcube.Size; bSampleCount = bcube.MultiSampleCount; } return((aFormatSize == bFormatSize) && (aWidth == bWidth) && (aHeight == bHeight) && (aSampleCount == bSampleCount)); }
public void GenerateCubeMap() { RenderTargetCube cube = new RenderTargetCube(graphics, 1024, true, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver2, 1, 1f, 50f); Camera camera = new Camera(graphics, position); camera.ProjectionMatrix = projection; graphics.SetRenderTarget(cube, CubeMapFace.PositiveZ); graphics.Clear(Color.Gray); camera.ViewMatrix = Matrix.CreateLookAt(position, position + Vector3.Backward, Vector3.Up); renderManager.Draw(camera); graphics.SetRenderTarget(cube, CubeMapFace.NegativeZ); graphics.Clear(Color.Gray); camera.ViewMatrix = Matrix.CreateLookAt(position, position + Vector3.Forward, Vector3.Up); renderManager.Draw(camera); graphics.SetRenderTarget(cube, CubeMapFace.NegativeX); graphics.Clear(Color.Gray); camera.ViewMatrix = Matrix.CreateLookAt(position, position + Vector3.Left, Vector3.Up); renderManager.Draw(camera); graphics.SetRenderTarget(cube, CubeMapFace.PositiveX); graphics.Clear(Color.Gray); camera.ViewMatrix = Matrix.CreateLookAt(position, position + Vector3.Right, Vector3.Up); renderManager.Draw(camera); graphics.SetRenderTarget(cube, CubeMapFace.PositiveY); graphics.Clear(Color.Gray); camera.ViewMatrix = Matrix.CreateLookAt(position, position + Vector3.Up, Vector3.Forward); renderManager.Draw(camera); graphics.SetRenderTarget(cube, CubeMapFace.NegativeY); graphics.Clear(Color.Gray); camera.ViewMatrix = Matrix.CreateLookAt(position, position + Vector3.Down, Vector3.Backward); renderManager.Draw(camera); cubeMap = cube; graphics.SetRenderTarget(null); }
protected override void Initialize() { base.Initialize(); // Größe und Position des Raums festlegen room.Size = new Vector3(1000.0f, 500.0f, 1000.0f); room.Position = new Vector3(0.0f, 250.0f, 0.0f); float sin = (float)Math.Sin(MathHelper.ToRadians(30.0f)); float cos = (float)Math.Cos(MathHelper.ToRadians(30.0f)); // Lichter hinzufügen lightService.Size = Vector3.One * 10.0f; lightService.Position = Vector3.Up * 100.0f; lightService.AddLight(new Vector3(0.0f, 0.0f, 1.0f) * 60.0f, Color.Red.ToVector3()); lightService.AddLight(new Vector3(+cos, 0.0f, -sin) * 60.0f, Color.Green.ToVector3()); lightService.AddLight(new Vector3(-cos, 0.0f, -sin) * 60.0f, Color.Blue.ToVector3()); // Kamera-Position festlegen camera.Position = new Vector3(0.0f, 80.0f, 200.0f); // Shadow Cube erstellen shadowCube = new RenderTargetCube(GraphicsDevice, 1024, false, SurfaceFormat.Single, DepthFormat.Depth24); int width = GraphicsDevice.PresentationParameters.BackBufferWidth; int height = GraphicsDevice.PresentationParameters.BackBufferHeight; // Blur Map erstellen blurMap = new RenderTarget2D(GraphicsDevice, width, height, false, SurfaceFormat.Single, DepthFormat.Depth24); spriteBatch = new SpriteBatch(GraphicsDevice); // Quad für Lightmap Blurring erstellen quadVertices = new VertexPositionTexture[4]; quadVertices[0] = new VertexPositionTexture(new Vector3(-1, -1, 0), new Vector2(0, 1)); quadVertices[1] = new VertexPositionTexture(new Vector3(-1, 1, 0), new Vector2(0, 0)); quadVertices[2] = new VertexPositionTexture(new Vector3(1, 1, 0), new Vector2(1, 0)); quadVertices[3] = new VertexPositionTexture(new Vector3(1, -1, 0), new Vector2(1, 1)); quadIndices = new int[] { 0, 1, 2, 2, 3, 0 }; }
//Constructor public PointLight(GraphicsDevice GraphicsDevice, Vector3 Position, float Radius, Vector4 Color, float Intensity, bool isWithShadows, int shadowMapResoloution) { //Set Position setPosition(Position); //Set Radius setRadius(Radius); //Set Color setColor(Color); //Set Intensity setIntensity(Intensity); //Set isWithShadows this.isWithShadows = isWithShadows; //Set shadowMapResoloution this.shadowMapResoloution = shadowMapResoloution; //Make ShadowMap shadowMap = new RenderTargetCube(GraphicsDevice, getShadowMapResoloution(), false, SurfaceFormat.Single, DepthFormat.Depth24Stencil8); }
/// <inheritdoc /> protected override void LoadContent() { // We load the city meshes into a model Scene = Game.Content.Load <Model>(ContentFolder3D + "scene/city"); Sphere = new SpherePrimitive(GraphicsDevice, 100f, 16, Color.White); // Load the tank which will contain reflections Robot = Game.Content.Load <Model>(ContentFolder3D + "tgcito-classic/tgcito-classic"); // Load the shadowmap effect Effect = Game.Content.Load <Effect>(ContentFolderEffects + "EnvironmentMap"); BasicEffect = (BasicEffect)Robot.Meshes.FirstOrDefault().Effects[0]; // Assign the Environment map effect to our robot foreach (var modelMesh in Robot.Meshes) { foreach (var part in modelMesh.MeshParts) { part.Effect = Effect; } } DebugTextureEffect = Game.Content.Load <Effect>(ContentFolderEffects + "DebugTexture"); DebugTextureEffect.CurrentTechnique = DebugTextureEffect.Techniques["DebugCubeMap"]; // Create a full screen quad to debug the environment map FullScreenQuad = new FullScreenQuad(GraphicsDevice); QuadWorld = Matrix.CreateScale(new Vector3(0.9f, 0.2f, 0f)) * Matrix.CreateTranslation(Vector3.Down * 0.7f); // Create a render target for the scene EnvironmentMapRenderTarget = new RenderTargetCube(GraphicsDevice, EnvironmentmapSize, false, SurfaceFormat.Color, DepthFormat.Depth24, 0, RenderTargetUsage.DiscardContents); GraphicsDevice.BlendState = BlendState.Opaque; base.LoadContent(); }
/// <summary> /// Creates ViewLayerHDR instance /// </summary> /// <param name="Game">Game engine</param> /// <param name="width">Target width.</param> /// <param name="height">Target height.</param> public RenderWorld(Game game, int width, int height) { Game = game; this.rs = Game.RenderSystem; Camera = new Camera(); var vp = Game.GraphicsDevice.DisplayBounds; if (width <= 0) { width = vp.Width; } if (height <= 0) { height = vp.Height; } HdrSettings = new HdrSettings(); SkySettings = new SkySettings(); DofSettings = new DofSettings(); FogSettings = new FogSettings(); Instances = new List <MeshInstance>(); LightSet = new LightSet(Game.RenderSystem); debug = new DebugRender(Game); particleSystem = new ParticleSystem(Game.RenderSystem, this); MeasuredOld = new RenderTarget2D(Game.GraphicsDevice, ColorFormat.Rgba32F, 1, 1); MeasuredNew = new RenderTarget2D(Game.GraphicsDevice, ColorFormat.Rgba32F, 1, 1); radianceFrame = new HdrFrame(Game, 512, 512); Radiance = new RenderTargetCube(Game.GraphicsDevice, ColorFormat.Rgba16F, RenderSystem.EnvMapSize, true); RadianceCache = new TextureCubeArray(Game.GraphicsDevice, 128, RenderSystem.MaxEnvLights, ColorFormat.Rgba16F, true); Resize(width, height); }
/// <summary> /// Initializes a new instance of the <see cref="RenderTargetFormat"/> struct. /// </summary> /// <param name="renderTargetCube"> /// The <see cref="RenderTargetCube"/> from which the settings are copied. Can be /// <see langword="null"/> to set all properties to undefined. /// </param> public RenderTargetFormat(RenderTargetCube renderTargetCube) { if (renderTargetCube == null) { _width = null; _height = null; _mipmap = null; _surfaceFormat = null; _depthStencilFormat = null; _multiSampleCount = null; _renderTargetUsage = null; } else { _width = renderTargetCube.Size; _height = renderTargetCube.Size; _mipmap = renderTargetCube.LevelCount > 1; _surfaceFormat = renderTargetCube.Format; _depthStencilFormat = renderTargetCube.DepthStencilFormat; _multiSampleCount = renderTargetCube.MultiSampleCount; _renderTargetUsage = renderTargetCube.RenderTargetUsage; } }
/// <summary> /// /// </summary> public override void Initialize() { skyCube = new RenderTargetCube(rs, ColorFormat.Rgba16F, 128, true); skyConstsCB = new ConstantBuffer(rs, typeof(SkyConsts)); LoadContent(); Game.Reloading += (s, e) => LoadContent(); randVectors = new Vector3[64]; for (int i = 0; i < randVectors.Length; i++) { Vector3 randV; do { randV = rand.NextVector3(-Vector3.One, Vector3.One); } while (randV.Length() > 1 && randV.Y < 0); randVectors[i] = randV.Normalized(); } }
public void UpdateShadow() { if (shadowMap == null) { shadowMap = new RenderTargetCube(Game1.instance.GraphicsDevice, 64, false, SurfaceFormat.Rg32, DepthFormat.Depth16); } needUpdate = false; Effect effect = Game1.instance.fxShadowPass; effect.CurrentTechnique = effect.Techniques[0]; // We need to render the whole shabam 6 times Matrix projMatrix = Matrix.CreatePerspectiveFieldOfView( MathHelper.PiOver2, 1, 1, mo.infol.light.radius); Matrix viewMatrix = Matrix.Identity; int lump; r_local.spritedef_t sprdef; r_local.spriteframe_t sprframe; sprdef = r_thing.sprites[(int)mo.sprite]; sprframe = sprdef.spriteframes[mo.frame & DoomDef.FF_FRAMEMASK]; lump = sprframe.lump[0]; Texture2D texture = w_wad.W_CacheLumpNum(lump + r_data.firstspritelump, DoomDef.PU_CACHE).cache as Texture2D; lightPos = new Vector3( mo.x >> DoomDef.FRACBITS, mo.y >> DoomDef.FRACBITS, ((mo.z + r_data.spritetopoffset[lump]) >> DoomDef.FRACBITS) - texture.Height / 2); effect.Parameters["lightPos"].SetValue(lightPos); effect.Parameters["radius"].SetValue(mo.infol.light.radius); for (int i = 0; i < 6; i++) { // render the scene to all cubemap faces CubeMapFace cubeMapFace = (CubeMapFace)i; switch (cubeMapFace) { case CubeMapFace.NegativeX: { viewMatrix = Matrix.CreateLookAt(lightPos, lightPos + Vector3.Left, Vector3.Up); break; } case CubeMapFace.NegativeY: { viewMatrix = Matrix.CreateLookAt(lightPos, lightPos + Vector3.Down, Vector3.Forward); break; } case CubeMapFace.NegativeZ: { viewMatrix = Matrix.CreateLookAt(lightPos, lightPos + Vector3.Backward, Vector3.Up); break; } case CubeMapFace.PositiveX: { viewMatrix = Matrix.CreateLookAt(lightPos, lightPos + Vector3.Right, Vector3.Up); break; } case CubeMapFace.PositiveY: { viewMatrix = Matrix.CreateLookAt(lightPos, lightPos + Vector3.Up, Vector3.Backward); break; } case CubeMapFace.PositiveZ: { viewMatrix = Matrix.CreateLookAt(lightPos, lightPos + Vector3.Forward, Vector3.Up); break; } } effect.Parameters["matWorldViewProj"].SetValue(viewMatrix * projMatrix); effect.CurrentTechnique.Passes[0].Apply(); // Set the cubemap render target, using the selected face Game1.instance.GraphicsDevice.SetRenderTarget(shadowMap, cubeMapFace); Game1.instance.GraphicsDevice.Clear(Color.White); Game1.instance.GraphicsDevice.DepthStencilState = DepthStencilState.Default; DrawScene(); } }
public EnvironmentmappingComponent(RenderTarget2D target, RenderTargetCube targetCube, TextureCube map) : this(target, targetCube) { environmentMap = map; }
public EnvironmentmappingComponent(RenderTarget2D target, RenderTargetCube targetCube) { renderTarget = target; renderTargetCube = targetCube; }
public RenderCubeAsset(RenderTargetCube Value) { this.Value = Value; }