//Creates a white 1*1 Texture that is used for the lines by scaling and rotating it
public void CreatePixelTexture()
{
int TargetWidth = 1;
int TargetHeight = 1;
RenderTarget2D LevelRenderTarget = new RenderTarget2D(graphicsDevice, TargetWidth, TargetHeight, 1,
graphicsDevice.PresentationParameters.BackBufferFormat, graphicsDevice.PresentationParameters.MultiSampleType,
graphicsDevice.PresentationParameters.MultiSampleQuality, RenderTargetUsage.PreserveContents);
DepthStencilBuffer stencilBuffer = new DepthStencilBuffer(graphicsDevice, TargetWidth, TargetHeight,
graphicsDevice.DepthStencilBuffer.Format, graphicsDevice.PresentationParameters.MultiSampleType,
graphicsDevice.PresentationParameters.MultiSampleQuality);
graphicsDevice.SetRenderTarget(0, LevelRenderTarget);
// Cache the current depth buffer
DepthStencilBuffer old = graphicsDevice.DepthStencilBuffer;
// Set our custom depth buffer
graphicsDevice.DepthStencilBuffer = stencilBuffer;
graphicsDevice.Clear(Color.White);
graphicsDevice.SetRenderTarget(0, null);
// Reset the depth buffer
graphicsDevice.DepthStencilBuffer = old;
pixel = LevelRenderTarget.GetTexture();
}
protected override ShaderResourceView CreateShaderResourceView()
{
if (MultiSampleCount > 1)
{
return(new SharpDX.Direct3D11.ShaderResourceView
(GraphicsDevice._d3dDevice, _resolvedTexture.GetTexture()));
}
else
{
return(base.CreateShaderResourceView());
}
}
public void SetRenderTarget(int renderTargetIndex, RenderTarget2D renderTarget)
{
if (renderTargetIndex < 0 || renderTargetIndex >= renderTargets.Length)
{
throw new ArgumentOutOfRangeException("The specified index must be within the supported range.");
}
Gl.glBindFramebufferEXT(Gl.GL_FRAMEBUFFER_EXT, frameBufferIdentifier);
if (renderTarget == null)
{
// Detach the texture and depth buffer
Gl.glFramebufferTexture2DEXT(Gl.GL_FRAMEBUFFER_EXT, getColorAttachment(renderTargetIndex),
Gl.GL_TEXTURE_2D, 0, 0);
Gl.glFramebufferRenderbufferEXT(Gl.GL_FRAMEBUFFER_EXT, Gl.GL_DEPTH_ATTACHMENT_EXT,
Gl.GL_RENDERBUFFER_EXT, 0);
renderTargets[renderTargetIndex] = null;
// Deactivate the frame buffer when no more targets are connected.
if (--numActiveRenderTargets == 0)
{
Gl.glBindFramebufferEXT(Gl.GL_FRAMEBUFFER_EXT, 0);
}
return;
}
if (renderTarget.IsDisposed)
{
throw new ObjectDisposedException("SetRenderTarget is called after the render target has been disposed.");
}
// Connect texture and depth buffer
Gl.glFramebufferTexture2DEXT(Gl.GL_FRAMEBUFFER_EXT, getColorAttachment(renderTargetIndex), Gl.GL_TEXTURE_2D,
renderTarget.GetTexture().textureId, 0);
Gl.glFramebufferRenderbufferEXT(Gl.GL_FRAMEBUFFER_EXT, Gl.GL_DEPTH_ATTACHMENT_EXT,
Gl.GL_RENDERBUFFER_EXT, renderTarget.renderBufferIdentifier);
numActiveRenderTargets++;
int status = Gl.glCheckFramebufferStatusEXT(Gl.GL_FRAMEBUFFER_EXT);
if (status != Gl.GL_FRAMEBUFFER_COMPLETE_EXT)
{
throw new Exception("This should not occur.");
}
// Leave framebuffer active
}
// Token: 0x06002540 RID: 9536
// RVA: 0x000E0B84 File Offset: 0x000DED84
private Texture2D method_11(Color color_3, Color color_4, Color color_5, Color color_6, float float_1)
{
RenderTarget2D renderTarget2D = new RenderTarget2D(base.method_8(), 128, 1, 1, 1);
VertexPositionColor[] array = new VertexPositionColor[]
{
new VertexPositionColor(new Vector3(-0.5f, 0f, 0f), Color.get_TransparentBlack()),
new VertexPositionColor(new Vector3(0f, 0f, 0f), Color.get_TransparentBlack()),
new VertexPositionColor(new Vector3(0.078125f - float_1, 0f, 0f), color_3),
new VertexPositionColor(new Vector3(0.078125f + float_1, 0f, 0f), color_4),
new VertexPositionColor(new Vector3(0.1875f - float_1, 0f, 0f), color_4),
new VertexPositionColor(new Vector3(0.1875f + float_1, 0f, 0f), color_6),
new VertexPositionColor(new Vector3(1f, 0f, 0f), color_5),
new VertexPositionColor(new Vector3(1.5f, 0f, 0f), color_5)
};
RenderTarget2D renderTarget2D2 = (RenderTarget2D)base.method_8().GetRenderTarget(0);
base.method_8().SetRenderTarget(0, renderTarget2D);
base.method_8().get_RenderState().set_AlphaBlendEnable(false);
base.method_8().get_RenderState().set_DepthBufferEnable(false);
base.method_8().get_RenderState().set_AlphaTestEnable(false);
base.method_8().get_RenderState().set_BlendFunction(1);
base.method_8().get_RenderState().set_AlphaBlendOperation(1);
base.method_8().set_VertexDeclaration(new VertexDeclaration(base.method_8(), VertexPositionColor.VertexElements));
base.method_8().Clear(Color.get_PaleVioletRed());
base.method_9().set_World(Matrix.get_Identity());
base.method_9().set_Projection(Matrix.CreateOrthographicOffCenter(0f, 1f, 1f, -1f, -1f, 1f));
base.method_9().set_View(Matrix.get_Identity());
base.method_9().set_TextureEnabled(false);
base.method_9().set_Texture(null);
base.method_9().set_VertexColorEnabled(true);
base.method_9().Begin();
base.method_9().get_CurrentTechnique().get_Passes().get_Item(0).Begin();
base.method_8().DrawUserPrimitives<VertexPositionColor>(3, array, 0, 7);
base.method_9().get_CurrentTechnique().get_Passes().get_Item(0).End();
base.method_9().End();
base.method_8().ResolveRenderTarget(0);
Texture2D texture = renderTarget2D.GetTexture();
base.method_8().SetRenderTarget(0, renderTarget2D2);
return texture;
}
public Texture2D Generate2DNoise(NoiseParameters noiseParams, int width, int height, int mipCount)
{
Vector2 invRes = Vector2.One / new Vector2(width, height);
noise2DShader.SetupShader();
GFX.Device.SetVertexShaderConstant(0, invRes);
GFX.Device.SetPixelShaderConstant(0, invRes);
GFX.Device.SetPixelShaderConstant(1, new Vector4(noiseParams.Amplitude, noiseParams.Frequency, noiseParams.Persistance, noiseParams.Octaves));
GFX.Device.Textures[0] = ComputeRandomTexture(width / 2, height / 2);
RenderTarget2D rtNoise = new RenderTarget2D(GFX.Device, width, height, 1, SurfaceFormat.Color);
DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer;
GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge;
GFX.Device.SetRenderTarget(0, rtNoise);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.DepthStencilBuffer = dsOld;
Color[] colorData = new Color[width * height];
rtNoise.GetTexture().GetData<Color>(colorData);
Texture2D noiseTexture = new Texture2D(GFX.Device, width, height, mipCount, TextureUsage.None, SurfaceFormat.Color);
noiseTexture.SetData<Color>(colorData);
noiseTexture.GenerateMipMaps(TextureFilter.GaussianQuad);
return noiseTexture;
}
Vector2 GetTerrainPosition(Texture2D heightmap, Vector2 shapeScale, Vector2 heightRange, out float heightAtPosition, out float thetaAtPosition, List<Vector3> placedShapes)
{
Vector2 invRes = new Vector2(1.0f / (float)heightmap.Width, 1.0f / (float)heightmap.Height);
RenderTarget2D rtVariance = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Vector2);
RenderTarget2D rtNormal = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Vector2);
GFX.Device.Textures[0] = heightmap;
varianceShader.SetupShader();
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, invRes);
GFX.Device.SetPixelShaderConstant(0, invRes);
GFX.Device.SetRenderTarget(0, rtVariance);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.SetRenderTarget(0, rtNormal);
gradientShader.SetupShader();
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = null;
int bufferSize = heightmap.Width * heightmap.Height;
float[] heightData = new float[bufferSize];
Vector2[] varianceData = new Vector2[bufferSize];
rtVariance.GetTexture().GetData<Vector2>(varianceData);
Vector2[] gradientData = new Vector2[rtNormal.Width * rtNormal.Height];
rtNormal.GetTexture().GetData<Vector2>(gradientData);
switch (heightmap.Format)
{
case SurfaceFormat.Single:
heightmap.GetData<float>(heightData);
break;
case SurfaceFormat.Color:
Color[] colorData = new Color[bufferSize];
heightmap.GetData<Color>(colorData);
float invScale = 1.0f / 255.0f;
for (int i = 0; i < colorData.Length; i++)
heightData[i] = (float)colorData[i].R * invScale;
break;
}
List<Int2D> availableSpots = new List<Int2D>();
for (int x = 0; x < heightmap.Width; x++)
{
for (int y = 0; y < heightmap.Height; y++)
{
int index = x + y * heightmap.Width;
if (varianceData[index].Y >= heightRange.X && varianceData[index].Y <= heightRange.Y)
{
/*
Vector2 currPos = new Vector2(x, y) * invRes * 2.0f - Vector2.One;
bool canPlace = true;
for(int i = 0; i < placedShapes.Count; i++)
{
if (Vector2.Distance(currPos, new Vector2(placedShapes[i].X, placedShapes[i].Y)) <= placedShapes[i].Z)
{
canPlace = false;
break;
}
}
if(canPlace)*/
availableSpots.Add(new Int2D(x, y));
}
}
}
for (int i = 0; i < availableSpots.Count; i++)
{
Int2D temp = availableSpots[i];
int randIndex = RandomHelper.RandomGen.Next(i, availableSpots.Count);
availableSpots[i] = availableSpots[randIndex];
availableSpots[randIndex] = temp;
}
PriorityQueue<float, Int2D> plantSpots = new PriorityQueue<float, Int2D>();
for (int i = 0; i < availableSpots.Count; i++)
{
int index = availableSpots[i].X + availableSpots[i].Y * heightmap.Width;
Vector2 currPos = new Vector2(availableSpots[i].X, availableSpots[i].Y) * invRes * 2.0f - Vector2.One;
float netPriority = 0;
for (int j = 0; j < placedShapes.Count; j++)
{
float radius = Vector2.Distance(currPos, new Vector2(placedShapes[j].X, placedShapes[j].Y)) * placedShapes[j].Z;
if (radius == 0.0f)
radius = 0.001f;
netPriority += 1.0f / (radius * radius);
}
plantSpots.Enqueue(availableSpots[i], varianceData[index].X + netPriority);
}
Int2D randPos = plantSpots.ExtractMin();// availableSpots[RandomHelper.RandomGen.Next(0, availableSpots.Count)];
Vector2 pos = new Vector2(randPos.X, randPos.Y) * invRes * 2.0f - Vector2.One;
int placedIndex = randPos.X + randPos.Y * heightmap.Width;
heightAtPosition = varianceData[placedIndex].Y;
thetaAtPosition = (float)Math.Atan2(gradientData[placedIndex].Y, gradientData[placedIndex].X);
return pos;
}
public Texture2D CreateRoadAtlas(Texture2D[] input, SpriteBatch spriteBatch)
{
DepthStencilBuffer OldDSBuffer = m_GraphicsDevice.DepthStencilBuffer;
RenderTarget2D RTarget = new RenderTarget2D(m_GraphicsDevice, 512, 512, 0, SurfaceFormat.Color,
RenderTargetUsage.PreserveContents);
DepthStencilBuffer DSBuffer = new DepthStencilBuffer(m_GraphicsDevice, 512, 512,
OldDSBuffer.Format);
m_GraphicsDevice.DepthStencilBuffer = DSBuffer;
m_GraphicsDevice.SetRenderTarget(0, RTarget);
m_GraphicsDevice.Clear(Color.TransparentBlack);
spriteBatch.Begin();
for (int i = 0; i < 16; i++)
{
spriteBatch.Draw(input[i], new Rectangle((i%4) * 128, (int)(i/4.0)*128, 128, 128), Color.White);
}
spriteBatch.End();
m_GraphicsDevice.SetRenderTarget(0, null);
m_GraphicsDevice.DepthStencilBuffer = OldDSBuffer;
Texture2D Ret = RTarget.GetTexture();
RTarget.Dispose(); //free up memory used by render target, as we have moved the data to a texture.
return Ret;
}
public void DownsampleGlow(RenderTarget2D colorMap, RenderTarget2D lightMap, RenderTarget2D dataMap, RenderTarget2D emissiveMap)
{
bloomShader.SetupShader();
for(int i = 0; i <= 2; i++)
GFX.Inst.SetTextureFilter(i, TextureFilter.Linear);
GFX.Device.Textures[0] = colorMap.GetTexture();
GFX.Device.Textures[1] = lightMap.GetTexture();
GFX.Device.Textures[2] = dataMap.GetTexture();
Vector2 invRes = Vector2.One / new Vector2(colorMap.Width, colorMap.Height);
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, invRes);
GFX.Device.SetPixelShaderConstant(0, new Vector2(bloomBias, bloomMultiplier));
GFX.Device.SetRenderTarget(0, emissiveMap);
GFX.Device.Clear(Color.TransparentBlack);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
BlurRenderTarget(emissiveMap, BlurFilter.Box, 4);
}
public static Texture2D Scale(GraphicsDevice gd, Texture2D texture, float scaleX, float scaleY)
{
var newWidth = (int)(texture.Width * scaleX);
var newHeight = (int)(texture.Height * scaleY);
RenderTarget2D renderTarget = new RenderTarget2D(
gd,
newWidth, newHeight, 1,
SurfaceFormat.Color);
gd.SetRenderTarget(0, renderTarget);
SpriteBatch batch = new SpriteBatch(gd);
Rectangle destinationRectangle = new Rectangle(0, 0, newWidth, newHeight);
batch.Begin();
batch.Draw(texture, destinationRectangle, Color.White);
batch.End();
gd.SetRenderTarget(0, null);
var newTexture = renderTarget.GetTexture();
return newTexture;
}
void PerformBlur(Texture2D heightmap)
{
Shader heightBlur2DShader = ResourceManager.Inst.GetShader("HeightmapBlurMinMax");
RenderTarget2D paramTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldDepth, 1, SurfaceFormat.Vector4);
GFX.Device.SetPixelShaderConstant(GFXShaderConstants.VC_INVTEXRES, Vector2.One / new Vector2(DensityFieldWidth, DensityFieldDepth));
GFX.Device.SetPixelShaderConstant(0, Vector2.One / new Vector2(DensityFieldWidth, DensityFieldDepth));
heightBlur2DShader.SetupShader();
GFX.Device.Textures[0] = heightmap;
GFX.Device.SetRenderTarget(0, paramTarget);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
Shader gradShader = ResourceManager.Inst.GetShader("GradientHeightmap");
GFX.Device.Textures[0] = paramTarget.GetTexture();
gradShader.SetupShader();
RenderTarget2D gradTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldDepth, 1, SurfaceFormat.Single);
GFX.Device.SetRenderTarget(0, gradTarget);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = null;
Shader blurShader = ResourceManager.Inst.GetShader("VoxelBlur3x3x3");
srcTarget = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldHeight, 1, GFX.Inst.ByteSurfaceFormat);
DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer;
GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge;
blurShader.SetupShader();
GFX.Device.SetPixelShaderConstant(0, Vector3.One / new Vector3(DensityFieldWidth, DensityFieldHeight, DensityFieldDepth));
GFX.Device.SamplerStates[0].AddressU = TextureAddressMode.Clamp;
GFX.Device.SamplerStates[0].AddressV = TextureAddressMode.Clamp;
GFX.Device.SamplerStates[0].AddressW = TextureAddressMode.Clamp;
GFX.Device.RenderState.DepthBufferEnable = false;
GFX.Device.RenderState.DepthBufferWriteEnable = false;
//Here we generate our noise textures
int nSize = 32;
noiseTextures = new Texture3D[4];
float[] noiseData = new float[nSize * nSize * nSize];
Random rand = new Random();
for (int i = 0; i < noiseTextures.Length; i++)
{
noiseTextures[i] = new Texture3D(GFX.Device, nSize, nSize, nSize, 1, TextureUsage.None, SurfaceFormat.Single);
for (int j = 0; j < noiseData.Length; j++)
{
noiseData[j] = (float)(rand.NextDouble() * 2 - 1);
}
noiseTextures[i].SetData<float>(noiseData);
}
noiseData = null;
//Lets activate our textures
for (int i = 0; i < noiseTextures.Length; i++)
GFX.Device.Textures[i+3] = noiseTextures[i];
//CopyDensityTextureData(ref DensityField, currDensityField);
GFX.Device.Textures[0] = heightmap;
GFX.Device.Textures[1] = paramTarget.GetTexture();
GFX.Device.Textures[2] = gradTarget.GetTexture();
for (int z = 0; z < DensityFieldDepth; z++)
{
Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1);
GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth
GFX.Device.SetRenderTarget(0, srcTarget);
//GFX.Device.Clear(Color.TransparentBlack);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
//Now the copying stage.
ExtractDensityTextureData(ref DensityField, z);
}
GFX.Device.Textures[0] = null;
/*
Texture3D voxelTexture = new Texture3D(GFX.Device, DensityFieldWidth, DensityFieldHeight, DensityFieldDepth, 1, TextureUsage.None, GFX.Inst.ByteSurfaceFormat);
switch (GFX.Inst.ByteSurfaceDataType)
{
case GFXTextureDataType.BYTE:
voxelTexture.SetData<byte>(DensityField);
break;
case GFXTextureDataType.COLOR:
Color[] tempColor = new Color[DensityField.Length];
for(int i = 0; i < tempColor.Length; i++)
tempColor[i] = new Color(DensityField[i], DensityField[i], DensityField[i], DensityField[i]);
voxelTexture.SetData<Color>(tempColor);
tempColor = null;
break;
case GFXTextureDataType.SINGLE:
float[] tempFloat = new float[DensityField.Length];
float invScale = 1.0f / 255.0f;
for (int i = 0; i < tempFloat.Length; i++)
tempFloat[i] = (float)DensityField[i] * invScale;
voxelTexture.SetData<float>(tempFloat);
tempFloat = null;
break;
}
Shader blurShaderGeneric = ResourceManager.Inst.GetShader("VoxelBlurGeneric");
blurShaderGeneric.SetupShader();
GFX.Device.Textures[0] = voxelTexture;
for (int z = 0; z < DensityFieldDepth; z++)
{
Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1);
GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth
GFX.Device.SetRenderTarget(0, srcTarget);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
//Now the copying stage.
ExtractDensityTextureData(ref DensityField, z);
}
GFX.Device.Textures[0] = null;
voxelTexture.Dispose();
*/
GFX.Device.DepthStencilBuffer = dsOld;
GFX.Device.RenderState.DepthBufferEnable = true;
GFX.Device.RenderState.DepthBufferWriteEnable = true;
}
void AssembleTextureAtlas(Texture3D target, Texture2D[] srcTextures, int textureSize, int mipCount)
{
Shader imageShader = ResourceManager.Inst.GetShader("Generic2D");
RenderTarget2D rtTarget = new RenderTarget2D(GFX.Device, textureSize, textureSize, 1, SurfaceFormat.Color);
target = new Texture3D(GFX.Device, textureSize, textureSize, srcTextures.Length, mipCount, TextureUsage.AutoGenerateMipMap, SurfaceFormat.Color);
Color[] colorBuffer = new Color[textureSize * textureSize];
GFX.Device.SamplerStates[0].MagFilter = TextureFilter.Linear;
GFX.Device.SamplerStates[0].MinFilter = TextureFilter.Linear;
GFX.Device.SamplerStates[0].MipFilter = TextureFilter.Linear;
imageShader.SetupShader();
for (int i = 0; i < srcTextures.Length; i++)
{
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, Vector2.One / new Vector2(srcTextures[i].Width, srcTextures[i].Height));
GFX.Device.Textures[0] = srcTextures[i];
GFX.Device.SetRenderTarget(0, rtTarget);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
rtTarget.GetTexture().GetData<Color>(colorBuffer);
target.SetData<Color>(colorBuffer, colorBuffer.Length * i, colorBuffer.Length, SetDataOptions.None);
}
target.GenerateMipMaps(TextureFilter.Linear);
}
public void SetText(string text)
{
this.text = text;
width = (int)ServiceManager.Game.Font.MeasureString(text).X * 2;
height = (int)ServiceManager.Game.Font.MeasureString(text).Y * 2;
GraphicsDevice device = Renderer.GraphicOptions.graphics.GraphicsDevice;
const int numberOfLevels = 1;
const int multisampleQuality = 0;
RenderTarget2D renderTarget = new RenderTarget2D(device, width,
height, numberOfLevels, SurfaceFormat.Color,
MultiSampleType.None, multisampleQuality, RenderTargetUsage.PreserveContents);
device.SetRenderTarget(0, renderTarget);
device.Clear(Color.TransparentWhite);
ServiceManager.Game.Batch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Texture, SaveStateMode.SaveState);
//ServiceManager.Game.Batch.Begin();
ServiceManager.Game.Batch.DrawString(ServiceManager.Game.Font, text, Vector2.Zero, Color.Black, 0.0f, Vector2.Zero, 2.0f, SpriteEffects.None, 0f);
ServiceManager.Game.Batch.End();
device.SetRenderTarget(0, null);
texture = renderTarget.GetTexture();
//texture.Save("C:\\img.png", ImageFileFormat.Png);
AdjustVertices();
Ready();
}
void PopulateAtlas(Texture2D[] textures, Texture3D output)
{
RenderTarget2D rt = new RenderTarget2D(GFX.Device, output.Width, output.Height, 1, SurfaceFormat.Color);
int stride = output.Width * output.Height;
DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer;
GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge;
Shader drawImageShader = ResourceManager.Inst.GetShader("Generic2D");
drawImageShader.SetupShader();
GFX.Device.SamplerStates[0].AddressU = TextureAddressMode.Clamp;
GFX.Device.SamplerStates[0].AddressV = TextureAddressMode.Clamp;
GFX.Device.SamplerStates[0].AddressW = TextureAddressMode.Clamp;
GFX.Device.RenderState.DepthBufferEnable = false;
GFX.Device.RenderState.DepthBufferWriteEnable = false;
Color[] colorDataAtlas = new Color[stride * output.Depth];
for (int i = 0; i < textures.Length; i++)
{
GFX.Device.Textures[0] = textures[i];
GFX.Device.SetVertexShaderConstant(0, new Vector2(1.0f / textures[i].Width, 1.0f / textures[0].Height));
GFX.Device.SetRenderTarget(0, rt);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
rt.GetTexture().GetData<Color>(colorDataAtlas, i*stride, stride);
}
GFX.Device.Textures[0] = null;
GFX.Device.DepthStencilBuffer = dsOld;
GFX.Device.RenderState.DepthBufferEnable = true;
GFX.Device.RenderState.DepthBufferWriteEnable = true;
output.SetData<Color>(colorDataAtlas);
}
private void CopyTextureToRenderTarget(Texture2D src, RenderTarget2D rt, ref Texture2D dest)
{
var dsb = GraphicsDevice.DepthStencilBuffer;
GraphicsDevice.DepthStencilBuffer = null;
GraphicsDevice.SetRenderTarget(0, rt);
spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.None);
spriteBatch.Draw(src, new Rectangle(0, 0, src.Width, src.Height), Color.White);
spriteBatch.End();
GraphicsDevice.SetRenderTarget(0, null);
GraphicsDevice.DepthStencilBuffer = dsb;
dest = rt.GetTexture();
dest.GenerateMipMaps(TextureFilter.Linear);
}
public void Process(GraphicsDevice g, RenderTarget2D sceneTarget)
{
// extract brightest parts of the scene
g.SetRenderTarget(0, rTarget1);
Texture2D sceneTexture = sceneTarget.GetTexture();
ppManager.RenderScreenQuad(e, luminosityExtractTechnique, sceneTexture);
// blur the luminosity extract horizontally
g.SetRenderTarget(0, rTarget2);
e.Parameters["fWeights"].SetValue(horizontalBlurParameters.Weights);
e.Parameters["vOffsets"].SetValue(horizontalBlurParameters.Offsets);
ppManager.RenderScreenQuad(e, gaussianBlurTechnique, rTarget1.GetTexture());
// blur the luminosity extract vertically
g.SetRenderTarget(0, rTarget1);
e.Parameters["fWeights"].SetValue(verticalBlurParameters.Weights);
e.Parameters["vOffsets"].SetValue(verticalBlurParameters.Offsets);
ppManager.RenderScreenQuad(e, gaussianBlurTechnique, rTarget2.GetTexture());
// combine blurred luminosity extract with scene
g.SetRenderTarget(0, null);
g.Textures[1] = sceneTexture;
ppManager.RenderScreenQuad(e, compositeTechnique, rTarget1.GetTexture());
}
protected override void DrawWithClipRect()
{
if (Visible)
{
Vector2 drawPos = new Vector2(AbsoluteTransform.X, AbsoluteTransform.Y);
if (SourceRectangle.HasValue && IsPartiallyObscured)
{
//Game.GraphicsDevice.ScissorRectangle = SourceRectangle.Value;
//Game.GraphicsDevice.RenderState.ScissorTestEnable = true;
//Game.GraphicsDevice.SetRenderTarget(0, null);
RenderTarget2D renderTarget = new RenderTarget2D(Game.GraphicsDevice,
SourceRectangle.Value.Width,
SourceRectangle.Value.Height,
1,
SurfaceFormat.Color,
RenderTargetUsage.PreserveContents);
Game.GraphicsDevice.SetRenderTarget(0, renderTarget);
Game.GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.TransparentWhite, 1, 0);
//draw the text!
SpriteBatch spriteBatch = new SpriteBatch(Game.GraphicsDevice);
spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);
spriteBatch.DrawString(spriteFont,
Text,
new Vector2(SourceRectangle.Value.X, -SourceRectangle.Value.Y),
fontColor,
0,
Origin,
1,
SpriteEffects.None,
0);
spriteBatch.End();
Game.GraphicsDevice.SetRenderTarget(0, null);
//Game.GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.White, 1, 0);
_texture = renderTarget.GetTexture();
_guiManager.SpriteBatch.Draw(_texture,
drawPos + new Vector2(SourceRectangle.Value.X, SourceRectangle.Value.Y),
new Rectangle(0,0, SourceRectangle.Value.Width, SourceRectangle.Value.Height),
fontColor,
0f,
Vector2.Zero,
1f,
SpriteEffects.None,
0);
}
else if (!Parent.IsTotallyObscured)
{
//draw the text!
_guiManager.SpriteBatch.DrawString(spriteFont,
Text,
drawPos,
fontColor,
0,
Origin,
1,
SpriteEffects.None,
0);
}
//Game.GraphicsDevice.RenderState.ScissorTestEnable = false;
}
}
void PerformHistogramEqualization(Texture2D heightmap)
{
Vector2 MinMax = GetMinMaxHeight(heightmap);
RenderTarget2D rtHist = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, heightmap.Format);
GFX.Device.SetRenderTarget(0, rtHist);
GFX.Device.Textures[0] = heightmap;
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, new Vector2(1.0f / (float)heightmap.Width, 1.0f / (float)heightmap.Height));
GFX.Device.SetPixelShaderConstant(0, MinMax);
histogramShader.SetupShader();
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = null;
CopyToTexture(rtHist.GetTexture(), heightmap);
}
/// <summary>
/// Returns a custom texture of Perlin Noise
/// </summary>
public static Texture2D GeneratePerlinNoise(int TextureWidth, int TextureHeight
, Color[] NoiseData, int NoiseWidth, int NoiseHeight, float NoiseShift, float Sharpness)
{
isUsingGraphicsDevice = true;
while (MyGame.isDrawing)
{
Thread.Sleep(10);
}
RenderTarget2D renderTarget = new RenderTarget2D(MyGame.graphics.GraphicsDevice
, TextureWidth
, TextureHeight
, 1
, MyGame.graphics.GraphicsDevice.DisplayMode.Format);
MyGame.graphics.GraphicsDevice.SetRenderTarget(0, renderTarget);
DepthStencilBuffer OriginalBuffer = MyGame.graphics.GraphicsDevice.DepthStencilBuffer;
MyGame.graphics.GraphicsDevice.DepthStencilBuffer = new DepthStencilBuffer(MyGame.graphics.GraphicsDevice
, renderTarget.Width
, renderTarget.Height
, MyGame.graphics.GraphicsDevice.DepthStencilBuffer.Format);
Texture2D noiseMap = new Texture2D(MyGame.graphics.GraphicsDevice
, NoiseWidth
, NoiseHeight);
noiseMap.SetData<Color>(NoiseData);
PostProcessEffect.CurrentTechnique = PostProcessEffect.Techniques["GenerateNoise"];
PostProcessEffect.Parameters["InputTexture"].SetValue(noiseMap);
PostProcessEffect.Parameters["World"].SetValue(Matrix.Identity);
PostProcessEffect.Parameters["NoiseShift"].SetValue(NoiseShift);
PostProcessEffect.Parameters["Sharpness"].SetValue(Sharpness);
spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState);
PostProcessEffect.Begin();
PostProcessEffect.CurrentTechnique.Passes.First<EffectPass>().Begin();
spriteBatch.Draw(noiseMap
, new Rectangle(0, 0, renderTarget.Width, renderTarget.Height)
, Color.White);
PostProcessEffect.CurrentTechnique.Passes.First<EffectPass>().End();
PostProcessEffect.End();
spriteBatch.End();
MyGame.graphics.GraphicsDevice.SetRenderTarget(0, null);
MyGame.graphics.GraphicsDevice.DepthStencilBuffer = OriginalBuffer;
MyGame.graphics.GraphicsDevice.Clear(Color.Black);
isUsingGraphicsDevice = false;
return renderTarget.GetTexture();
}
//Debugging methods
public Texture2D GenTextureDebug(String text)
{
int w = (int)debugFont.MeasureString(text).X;
int h = (int)debugFont.MeasureString(text).Y;
RenderTarget2D render = new RenderTarget2D(GraphicsDevice, w, h, 1, GraphicsDevice.DisplayMode.Format
, GraphicsDevice.PresentationParameters.MultiSampleType
, GraphicsDevice.PresentationParameters.MultiSampleQuality
, RenderTargetUsage.DiscardContents);
GraphicsDevice.SetRenderTarget(0, render);
spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
spriteBatch.DrawString(debugFont, text, new Vector2(1, 1), Color.Black);
spriteBatch.DrawString(debugFont, text, new Vector2(0, 0), Color.White);
spriteBatch.End();
GraphicsDevice.SetRenderTarget(0, null);
return render.GetTexture();
}
void BuildBlendMap(Texture2D heightmap)
{
climate = ResourceManager.Inst.GetTerrainClimate("TestTerrain");
DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer;
GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge;
Shader gradientShader = ResourceManager.Inst.GetShader("GradientHeightmap");
gradientShader.SetupShader();
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, Vector2.One / new Vector2(heightmap.Width, heightmap.Height));
GFX.Device.SetPixelShaderConstant(0, Vector2.One / new Vector2(heightmap.Width, heightmap.Height));
GFX.Device.Textures[0] = heightmap;
RenderTarget2D rtGradient = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Single);
GFX.Device.SetRenderTarget(0, rtGradient);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = rtGradient.GetTexture();
RenderTarget2D rtCurvature = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Single);
GFX.Device.SetRenderTarget(0, rtCurvature);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
Shader blendShader = ResourceManager.Inst.GetShader("BlendHeightmap");
blendShader.SetupShader();
GFX.Device.Textures[0] = heightmap;
GFX.Device.Textures[1] = rtGradient.GetTexture();
GFX.Device.Textures[2] = rtCurvature.GetTexture();
Vector4[] climateParams = new Vector4[4];
Vector4[] climateParams2 = new Vector4[4];
int numBlendMapsNeeded = climate.blendZones.Length / 4;
blendMaps = new RenderTarget2D[numBlendMapsNeeded];
for (int i = 0; i < numBlendMapsNeeded; i++)
{
int offset = i * 4;
for (int j = 0; j < 4; j++)
{
int climateIndex = j + offset;
climateParams[j] = new Vector4(climate.heightCoeffs[climateIndex], climate.gradientCoeffs[climateIndex], climate.curvatureCoeffs[climateIndex], climate.baseScores[climateIndex]);
climateParams2[j] = Vector4.One * climate.blendZones[climateIndex];
}
GFX.Device.SetPixelShaderConstant(0, climateParams);
GFX.Device.SetPixelShaderConstant(4, climateParams2);
blendMaps[i] = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Color);
GFX.Device.SetRenderTarget(0, blendMaps[i]);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
}
NormalizeBlendWeights();
GFX.Device.DepthStencilBuffer = dsOld;
}
/*
void InitializeMaterial()
{
terrainMaterial.SetTexture(0, climate.BaseMapAtlas);
terrainMaterial.SetTexture(1, climate.NormalMapAtlas);
TextureResource blendTex = new TextureResource();
blendTex.SetTexture(TextureResourceType.Texture3D, blendTexture);
TextureResource blendIDTex = new TextureResource();
blendIDTex.SetTexture(TextureResourceType.Texture3D, blendIDTexture);
terrainMaterial.SetTexture(2, blendTex);
terrainMaterial.SetTexture(3, blendIDTex);
terrainMaterial.kAmbient = climate.GetInverseResolution();
terrainMaterial.kDiffuse = Vector3.One / new Vector3(blendMapWidth, blendMapHeight, blendMapDepth);
}
*/
void InitializeClimateMap()
{
Texture3D densityFieldTexture = new Texture3D(GFX.Device, DensityFieldWidth, DensityFieldHeight, DensityFieldDepth, 1, TextureUsage.None, GFX.Inst.ByteSurfaceFormat);
CopyDensityTextureData(ref DensityField, densityFieldTexture);
GFX.Device.Textures[0] = densityFieldTexture;
RenderTarget2D rtClimateMap = new RenderTarget2D(GFX.Device, blendMapWidth, blendMapHeight, 1, SurfaceFormat.Color);
RenderTarget2D rtIDMap = new RenderTarget2D(GFX.Device, blendMapWidth, blendMapHeight, 1, SurfaceFormat.Color);
int stride = blendMapWidth * blendMapHeight;
Color[] colorData = new Color[stride * blendMapDepth];
Color[] blendIDData = new Color[stride * blendMapDepth];
Vector4[] climateParams = new Vector4[4];
Vector4[] climateParams2 = new Vector4[4];
for (int i = 0; i < climate.heightCoeffs.Length; i++)
{
climateParams[i] = new Vector4(climate.heightCoeffs[i], climate.gradientCoeffs[i], climate.curvatureCoeffs[i], climate.baseScores[i]);
climateParams2[i] = Vector4.One * climate.blendZones[i];
}
GFX.Device.SetPixelShaderConstant(0, Vector3.One / new Vector3(DensityFieldWidth, DensityFieldHeight, DensityFieldDepth));
RenderTarget2D rtGradientMap = new RenderTarget2D(GFX.Device, DensityFieldWidth, DensityFieldHeight, 1, SurfaceFormat.Single);
int gradStride = DensityFieldWidth * DensityFieldHeight;
float[] gradientValues = new float[gradStride * DensityFieldDepth];
Texture3D gradientTexture = new Texture3D(GFX.Device, DensityFieldWidth, DensityFieldHeight, DensityFieldDepth, 1, TextureUsage.None, SurfaceFormat.Single);
Shader gradientShader = ResourceManager.Inst.GetShader("GradientShader");
gradientShader.SetupShader();
for (int z = 0; z < DensityFieldDepth; z++)
{
Vector4 depth = Vector4.One * (float)z / (float)(DensityFieldDepth - 1);
GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth
GFX.Device.SetRenderTarget(0, rtGradientMap);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
rtGradientMap.GetTexture().GetData<float>(gradientValues, z * gradStride, gradStride);
}
gradientTexture.SetData<float>(gradientValues);
GFX.Device.Textures[1] = gradientTexture;
GFX.Device.SetPixelShaderConstant(1, climateParams);
GFX.Device.SetPixelShaderConstant(5, climateParams2);
Shader climateShader = ResourceManager.Inst.GetShader("ClimateShader");
climateShader.SetupShader();
for (int z = 0; z < blendMapDepth; z++)
{
Vector4 depth = Vector4.One * (float)z / (float)(blendMapDepth - 1);
GFX.Device.SetVertexShaderConstant(0, depth); //Set our current depth
GFX.Device.SetRenderTarget(0, rtClimateMap);
GFX.Device.SetRenderTarget(1, rtIDMap);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.SetRenderTarget(1, null);
rtClimateMap.GetTexture().GetData<Color>(colorData, z * stride, stride);
rtIDMap.GetTexture().GetData<Color>(blendIDData, z * stride, stride);
}
GFX.Device.Textures[0] = null;
GFX.Device.Textures[1] = null;
gradientTexture.Dispose();
blendTexture = new Texture3D(GFX.Device, blendMapWidth, blendMapHeight, blendMapDepth, 1, TextureUsage.None, SurfaceFormat.Color);
blendTexture.SetData<Color>(colorData);
blendIDTexture = new Texture3D(GFX.Device, blendMapWidth, blendMapHeight, blendMapDepth, 1, TextureUsage.None, SurfaceFormat.Color);
blendIDTexture.SetData<Color>(blendIDData);
blendTexture.Save("TestClimateMap.dds", ImageFileFormat.Dds);
blendIDTexture.Save("TestClimateMapID.dds", ImageFileFormat.Dds);
}
void LoadHeightFromTexture()
{
Texture2D tex = Texture2D.FromFile(GFX.Device, heightmapFileName);
width = tex.Width;
depth = tex.Height;
heightValues = new float[width * depth];
byte[] data = new byte[width * depth];
if (tex.Format != SurfaceFormat.Luminance8)
{
Color[] dataColor = new Color[tex.Width * tex.Height];
tex.GetData<Color>(dataColor, 0, dataColor.Length);
for (int i = 0; i < dataColor.Length; i++)
data[i] = dataColor[i].R;
}
else
{
tex.GetData<byte>(data);
}
float scale = (heightRange.Y - heightRange.X);
for (int x = 0; x < width; x++)
{
for (int z = 0; z < depth; z++)
{
int index = x + width * z;
heightValues[index] = (float)((data[index] / 255.0f) * scale) + heightRange.X;
}
}
MaximumHeight = scale + heightRange.X;
Shader basic2DShader = ResourceManager.Inst.GetShader("Generic2D");
basic2DShader.SetupShader();
GFX.Device.Textures[0] = tex;
GFX.Device.SetVertexShaderConstant(0, Vector2.One / new Vector2(width - 1, depth - 1));
GFX.Inst.SetTextureFilter(0, TextureFilter.Linear);
RenderTarget2D heightmapSmaller = new RenderTarget2D(GFX.Device, width - 1, depth - 1, 1, SurfaceFormat.Color);
DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer;
GFX.Device.DepthStencilBuffer = GFX.Inst.dsBufferLarge;
GFX.Device.SetRenderTarget(0, heightmapSmaller);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.DepthStencilBuffer = dsOld;
BuildBlendMap(heightmapSmaller.GetTexture());
GenerateNormalMap();
}
/// <summary>
/// Erases the corners and center of input texture and warps the rest into a spiral
/// </summary>
public static Texture2D SpiralWarp(Texture2D texture)
{
isUsingGraphicsDevice = true;
while (MyGame.isDrawing)
{
Thread.Sleep(10);
}
RenderTarget2D renderTarget = new RenderTarget2D(MyGame.graphics.GraphicsDevice
, texture.Width
, texture.Width
, 1
, MyGame.graphics.GraphicsDevice.DisplayMode.Format);
MyGame.graphics.GraphicsDevice.SetRenderTarget(0, renderTarget);
DepthStencilBuffer OriginalBuffer = MyGame.graphics.GraphicsDevice.DepthStencilBuffer;
MyGame.graphics.GraphicsDevice.DepthStencilBuffer = new DepthStencilBuffer(MyGame.graphics.GraphicsDevice
, renderTarget.Width
, renderTarget.Height
, MyGame.graphics.GraphicsDevice.DepthStencilBuffer.Format);
PostProcessEffect.CurrentTechnique = PostProcessEffect.Techniques["SpiralWarp"];
PostProcessEffect.Parameters["InputTexture"].SetValue(texture);
PostProcessEffect.Parameters["World"].SetValue(Matrix.Identity);
PostProcessEffect.Parameters["WarpMagnitude"].SetValue(2.5f + 1.5f * (float)MyGame.random.NextDouble());
spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState);
PostProcessEffect.Begin();
PostProcessEffect.CurrentTechnique.Passes.First<EffectPass>().Begin();
spriteBatch.Draw(texture
, new Rectangle(0, 0, renderTarget.Width, renderTarget.Height)
, Color.White);
PostProcessEffect.CurrentTechnique.Passes.First<EffectPass>().End();
PostProcessEffect.End();
spriteBatch.End();
MyGame.graphics.GraphicsDevice.SetRenderTarget(0, null);
MyGame.graphics.GraphicsDevice.DepthStencilBuffer = OriginalBuffer;
MyGame.graphics.GraphicsDevice.Clear(Color.Black);
isUsingGraphicsDevice = false;
return renderTarget.GetTexture();
}
void DrawBlur(float x, float y, Effect effectToUse,
RenderTarget2D source, RenderTarget2D target)
{
SetBlurEffectParameters(x, y, effectToUse);
GraphicsDevice.SetRenderTarget(0, target);
spriteBatch.Begin(SpriteBlendMode.None,
SpriteSortMode.Immediate,
SaveStateMode.None);
effectToUse.Begin();
effectToUse.CurrentTechnique.Passes[0].Begin();
spriteBatch.Draw(source.GetTexture(),
new Rectangle(0, 0,
target.Width,
target.Height), Color.White);
spriteBatch.End();
effectToUse.CurrentTechnique.Passes[0].End();
effectToUse.End();
}
void GenerateNormalMap()
{
Texture2D heightmap = new Texture2D(GFX.Device, width, depth, 1, TextureUsage.None, SurfaceFormat.Single);
heightmap.SetData<float>(heightValues);
Vector2 invRes = Vector2.One / new Vector2(heightmap.Width, heightmap.Height);
Shader normalTangentShader = ResourceManager.Inst.GetShader("NormalTangentHeightmap");
normalTangentShader.SetupShader();
GFX.Device.SetVertexShaderConstant(0, invRes);
GFX.Device.SetPixelShaderConstant(0, invRes);
GFX.Device.SetPixelShaderConstant(1, Vector4.One / MaximumHeight);
GFX.Device.Textures[0] = heightmap;
GFX.Inst.SetTextureFilter(0, TextureFilter.Linear);
RenderTarget2D normTanTarget = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Vector4);
DepthStencilBuffer dsOld = GFX.Device.DepthStencilBuffer;
DepthStencilBuffer dsNew = new DepthStencilBuffer(GFX.Device, heightmap.Width, heightmap.Height, dsOld.Format);
GFX.Device.DepthStencilBuffer = dsNew;
GFX.Device.SetRenderTarget(0, normTanTarget);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.DepthStencilBuffer = dsOld;
normalTexture = normTanTarget.GetTexture();
}
void ApplyErosion(Texture2D heightmap, int iterations, float initialParticleCoverage)
{
Color[] heightDataOrig = new Color[heightmap.Width * heightmap.Height];
heightmap.GetData<Color>(heightDataOrig);
float[] heightValues = new float[heightDataOrig.Length];
for (int i = 0; i < heightDataOrig.Length; i++)
heightValues[i] = (float)heightDataOrig[i].R / 255.0f;
RenderTarget2D normalTarget = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, SurfaceFormat.Vector2);
int numParticles = (int)(initialParticleCoverage * heightmap.Width * heightmap.Height);
ErosionParticle[] particles = new ErosionParticle[numParticles];
for (int k = 0; k < iterations; k++)
{
Vector2 invRes = new Vector2(1.0f / (float)heightmap.Width, 1.0f / (float)heightmap.Height);
GFX.Device.SetRenderTarget(0, normalTarget);
gradientShader.SetupShader();
GFX.Device.Textures[0] = heightmap;
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, invRes);
GFX.Device.SetPixelShaderConstant(0, invRes);
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
Vector2[] gradientData = new Vector2[normalTarget.Width * normalTarget.Height];
normalTarget.GetTexture().GetData<Vector2>(gradientData);
for (int i = 0; i < numParticles; i++)
{
particles[i].x = RandomHelper.RandomGen.Next(heightmap.Width - 1);
particles[i].y = RandomHelper.RandomGen.Next(heightmap.Height - 1);
particles[i].sediment = 0;
int oldX = particles[i].x;
int oldY = particles[i].y;
while (true)
{
int index = particles[i].x + particles[i].y * heightmap.Width;
float oldHeight = heightValues[index];
float heightAmount = heightValues[index] * 0.035f;
heightValues[index] -= heightAmount;
particles[i].sediment += heightAmount;
Vector2 gradient = gradientData[index];
int shiftX = (gradient.X < 0.25f) ? -1 : (gradient.X > 0.25f) ? 1 : 0;
int shiftY = (gradient.Y < 0.25f) ? -1 : (gradient.Y > 0.25f) ? 1 : 0;
int newX = (int)(particles[i].x + shiftX);
int newY = (int)(particles[i].y + shiftY);
if (newX < 0 || newY < 0 || newX >= heightmap.Width || newY >= heightmap.Height)
break;
if (heightValues[newX + newY * heightmap.Width] > heightValues[index] || (newX == oldX && newY == oldY))
{
heightValues[index] += particles[i].sediment;
break;
}
oldX = particles[i].x;
oldY = particles[i].y;
particles[i].x = newX;
particles[i].y = newY;
}
}
GFX.Device.Textures[0] = null;
for (int i = 0; i < heightDataOrig.Length; i++)
{
byte value = (byte)(heightValues[i] * 255.0f);
heightDataOrig[i].R = value;
heightDataOrig[i].G = value;
heightDataOrig[i].B = value;
heightDataOrig[i].A = value;
}
heightmap.SetData<Color>(heightDataOrig);
}
}
public static Texture2D Resize(GraphicsDevice gd, Texture2D texture, int newWidth, int newHeight)
{
RenderTarget2D renderTarget = new RenderTarget2D(
gd,
newWidth, newHeight, 1,
SurfaceFormat.Color);
SpriteBatch batch = new SpriteBatch(gd);
Rectangle destinationRectangle = new Rectangle(0, 0, newWidth, newHeight);
lock (gd)
{
gd.SetRenderTarget(0, renderTarget);
batch.Begin();
batch.Draw(texture, destinationRectangle, Color.White);
batch.End();
gd.SetRenderTarget(0, null);
}
var newTexture = renderTarget.GetTexture();
return newTexture;
}
void CreateConstraints(Texture2D heightmap, out SortedList<int, Vector4> landmarks)
{
RenderTarget2D rtHeightmap = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, heightmap.Format);
float[] numDirs = new float[4] { 0, MathHelper.PiOver2, MathHelper.Pi, 3.0f * MathHelper.PiOver2 };
GFX.Device.SetRenderTarget(0, rtHeightmap);
float randomRot = numDirs[RandomHelper.RandomGen.Next(0, numDirs.Length)];
CreateLerpLayer(heightmap, GetRandomIsland(), false, 0, 0.28f, Vector2.One, randomRot, Vector2.Zero);
GFX.Device.SetRenderTarget(0, null);
CopyToTexture(rtHeightmap.GetTexture(), heightmap);
List<Vector3> placedLocations = new List<Vector3>();
landmarks = new SortedList<int, Vector4>();
for(int i = 0; i < creationDatablock.MapLocations.Length; i++)
{
TerrainCreationParameters currParams = creationDatablock.MapLocations[i];
if(currParams != null)
{
float baseHeight;
float theta = 0;
Vector2 position = GetTerrainPosition(heightmap, currParams.Scale, currParams.HeightRange, out baseHeight, out theta, placedLocations);
switch (currParams.Rotation)
{
case RotationParameters.Fixed:
theta = 0;
break;
case RotationParameters.FourAngles:
theta = numDirs[RandomHelper.RandomGen.Next(0, numDirs.Length)];
break;
case RotationParameters.Random:
theta = (float)RandomHelper.RandomGen.NextDouble() * MathHelper.TwoPi;
break;
}
GFX.Device.SetRenderTarget(0, rtHeightmap);
DrawImage(heightmap);
CreateLerpLayer(heightmap, currParams.Mask.GetTexture() as Texture2D, true, baseHeight, currParams.Intensity, currParams.Scale, theta, position);
GFX.Device.SetRenderTarget(0, null);
CopyToTexture(rtHeightmap.GetTexture(), heightmap);
landmarks.Add(i, new Vector4(position.X, position.Y, baseHeight, theta));
placedLocations.Add(new Vector3(position.X, position.Y, currParams.RepulsionFactor));
//placedLocations.Add(new Vector3(position.X, position.Y, currParams.Scale.Length() * currParams.RepulsionFactor));
}
}
}
public void BlurRenderTarget(RenderTarget2D target, BlurFilter filterType, int blurPasses)
{
Vector2 invRes = Vector2.One / new Vector2(target.Width, target.Height);
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, invRes);
GFX.Device.SetPixelShaderConstant(1, Vector4.One * 0.015f);
GFX.Device.SetPixelShaderConstant(0, invRes);
Shader activeHShader = boxBlurHShader;
Shader activeVShader = boxBlurVShader;
switch (filterType)
{
case BlurFilter.Gauss:
activeHShader = gaussBlurHShader;
activeVShader = gaussBlurVShader;
break;
}
for (int i = 0; i < blurPasses; i++)
{
GFX.Device.Textures[0] = target.GetTexture();
GFX.Device.SetRenderTarget(0, target);
activeHShader.SetupShader();
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = target.GetTexture();
GFX.Device.SetRenderTarget(0, target);
activeVShader.SetupShader();
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
}
}
void CreateLayer(Texture2D heightmap, LayerMode mode, BlendMode blendMode, PlacementParameters parameters)
{
RenderTarget2D rtPeaks = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, heightmap.Format);
GFX.Device.SetRenderTarget(0, rtPeaks);
DrawImage(heightmap);
GFX.Device.RenderState.AlphaBlendEnable = true;
switch (blendMode)
{
case BlendMode.Additive:
GFX.Device.RenderState.SourceBlend = Blend.One;
GFX.Device.RenderState.DestinationBlend = Blend.One;
break;
case BlendMode.SoftAdditive:
GFX.Device.RenderState.SourceBlend = Blend.InverseDestinationColor;
GFX.Device.RenderState.DestinationBlend = Blend.One;
break;
case BlendMode.Multiply:
GFX.Device.RenderState.SourceBlend = Blend.DestinationColor;
GFX.Device.RenderState.DestinationBlend = Blend.Zero;
break;
case BlendMode.Interpolate:
GFX.Device.RenderState.SourceBlend = Blend.SourceAlpha;
GFX.Device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
break;
}
peakShader.SetupShader();
int count = RandomHelper.RandomGen.Next(parameters.MinCount, parameters.MaxCount);
for (int i = 0; i < count; i++)
{
Vector2 res = Vector2.One;
switch (mode)
{
case LayerMode.Peaks:
GFX.Device.Textures[0] = whiteTexture;
break;
case LayerMode.Mountains:
Texture2D mountainMap = GFX.Inst.PerlinNoiseGen.Generate2DNoise(mountainParams, mountainRes, mountainRes, 1);
GFX.Device.Textures[0] = mountainMap;
res = new Vector2(mountainRes, mountainRes);
break;
}
float amplitude = MathHelper.Lerp(parameters.MinAmplitude, parameters.MaxAmplitude, (float)RandomHelper.RandomGen.NextDouble());
float falloff = MathHelper.Lerp(parameters.MinFalloff, parameters.MaxFalloff, (float)RandomHelper.RandomGen.NextDouble());
Vector4 peakParameters = new Vector4(amplitude, falloff, 0, 0);
Vector2 randPos = new Vector2((float)RandomHelper.RandomGen.NextDouble(), (float)RandomHelper.RandomGen.NextDouble()) * 2.0f - Vector2.One;
Vector2 randRadius = Vector2.Lerp(parameters.MinSize, parameters.MaxSize, (float)RandomHelper.RandomGen.NextDouble());
randPos = Vector2.Clamp(randPos, Vector2.One * -1 + randRadius, Vector2.One - randRadius);
GFX.Device.SetPixelShaderConstant(0, peakParameters);
GFX.Device.SetVertexShaderConstant(0, new Vector4(randRadius.X, randRadius.Y, randPos.X, randPos.Y));
GFX.Device.SetVertexShaderConstant(1, Vector4.Zero);
GFX.Device.SetVertexShaderConstant(2, Vector2.One / res);
}
GFX.Device.RenderState.AlphaBlendEnable = false;
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = null;
CopyToTexture(rtPeaks.GetTexture(), heightmap);
}
void CreateTerraces(Texture2D heightmap)
{
RenderTarget2D rtTerrace = new RenderTarget2D(GFX.Device, heightmap.Width, heightmap.Height, 1, heightmap.Format);
GFX.Device.SetRenderTarget(0, rtTerrace);
GFX.Device.Textures[0] = heightmap;
GFX.Device.SetVertexShaderConstant(GFXShaderConstants.VC_INVTEXRES, new Vector2(1.0f / (float)heightmap.Width, 1.0f / (float)heightmap.Height));
GFX.Device.SetPixelShaderConstant(0, new Vector4(terraceCount, terraceExp, 0, 0));
terraceShader.SetupShader();
GFXPrimitives.Quad.Render();
GFX.Device.SetRenderTarget(0, null);
GFX.Device.Textures[0] = null;
CopyToTexture(rtTerrace.GetTexture(), heightmap);
}
/// <summary>
/// Creates a transparency atlas with which to texture the terrain.
/// </summary>
/// <param name="spriteBatch">A spritebatch to draw with.</param>
public void CreateTransparencyAtlas(SpriteBatch spriteBatch)
{
DepthStencilBuffer OldDSBuffer = m_GraphicsDevice.DepthStencilBuffer;
RenderTarget2D RTarget = new RenderTarget2D(m_GraphicsDevice, 1024, 256, 0, SurfaceFormat.Color,
RenderTargetUsage.PreserveContents);
DepthStencilBuffer DSBuffer = new DepthStencilBuffer(m_GraphicsDevice, 1024, 256,
OldDSBuffer.Format);
m_GraphicsDevice.DepthStencilBuffer = DSBuffer;
m_GraphicsDevice.SetRenderTarget(0, RTarget);
m_GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
for (int i = 0; i < 30; i = i + 2)
{
spriteBatch.Draw(m_TransA[i], new Rectangle(i*32, 0, m_TransA[i].Width, m_TransA[i].Height), Color.White);
spriteBatch.Draw(m_TransA[i + 1], new Rectangle(i*32, 64, m_TransA[i + 1].Width, m_TransA[i + 1].Height), Color.White);
}
for (int i = 0; i < 30; i = i + 2)
{
spriteBatch.Draw(TransB[i], new Rectangle(i*32, 128, m_TransA[i].Width, m_TransA[i].Height), Color.White);
spriteBatch.Draw(TransB[i + 1], new Rectangle(i*32, 192, m_TransA[i + 1].Width, m_TransA[i + 1].Height), Color.White);
}
Texture2D black = new Texture2D(m_GraphicsDevice, 1, 1);
black.SetData<Color>(new Color[] { Color.Black });
spriteBatch.Draw(black, new Rectangle(1024-64, 0, 64, 256), Color.Black);
//fill far end with black to cause no blend if adjacency bitmask is "0000"
spriteBatch.End();
m_GraphicsDevice.SetRenderTarget(0, null);
m_GraphicsDevice.DepthStencilBuffer = OldDSBuffer;
TransAtlas = RTarget.GetTexture();
RTarget.Dispose(); //free up memory used by render target, as we have moved the data to a texture.
}
