/// <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;
}
