public RendererManaged.Texture2D CreateTextureCube(RendererManaged.Device _Device)
{
if (m_Opts.m_type != ImageOptions.TYPE.TT_CUBIC)
{
throw new Exception("The image is not a cube map texture!");
}
RendererManaged.PIXEL_FORMAT TextureFormat = m_Opts.m_format.EquivalentRendererFormat;
uint ArraySize = 6 * m_Opts.m_arraySize;
uint MipsCount = m_Opts.m_curNumLevels;
uint PixelSize = m_Opts.m_format.BitsCount >> 3;
List <RendererManaged.PixelsBuffer> Content = new List <RendererManaged.PixelsBuffer>();
for (uint SliceIndex = 0; SliceIndex < ArraySize; SliceIndex++)
{
for (uint MipLevelIndex = 0; MipLevelIndex < MipsCount; MipLevelIndex++)
{
ImageSlice Slice = m_Slices[MipLevelIndex * ArraySize + SliceIndex]; // Stupidly stored in reverse order!
RendererManaged.PixelsBuffer Pixels = new RendererManaged.PixelsBuffer((int)(Slice.m_Width * Slice.m_Height * PixelSize));
Content.Add(Pixels);
using (BinaryWriter Writer = Pixels.OpenStreamWrite())
Writer.Write(Slice.m_Content);
}
}
RendererManaged.Texture2D Result = new RendererManaged.Texture2D(_Device, (int)m_Opts.m_curWidth, (int)m_Opts.m_curHeight, -6 * (int)m_Opts.m_arraySize, (int)m_Opts.m_curNumLevels, TextureFormat, false, false, Content.ToArray());
return(Result);
}
private void buttonTestBilateral_Click(object sender, EventArgs e)
{
try {
panelParameters.Enabled = false;
//////////////////////////////////////////////////////////////////////////
// 1] Apply bilateral filtering to the input texture as a pre-process
ApplyBilateralFiltering(m_TextureSource, m_TextureTarget0, floatTrackbarControlBilateralRadius.Value, floatTrackbarControlBilateralTolerance.Value, checkBoxWrap.Checked, 100);
progressBar.Value = progressBar.Maximum;
//////////////////////////////////////////////////////////////////////////
// 2] Copy target to staging for CPU readback and update the resulting bitmap
m_TextureTarget_CPU.CopyFrom(m_TextureTarget0);
if (m_BitmapResult != null)
{
m_BitmapResult.Dispose();
}
m_BitmapResult = null;
m_BitmapResult = new ImageUtility.Bitmap(W, H, m_ProfileLinear);
m_BitmapResult.HasAlpha = true;
RendererManaged.PixelsBuffer Pixels = m_TextureTarget_CPU.Map(0, 0);
using (System.IO.BinaryReader R = Pixels.OpenStreamRead())
for (int Y = 0; Y < H; Y++)
{
R.BaseStream.Position = Y * Pixels.RowPitch;
for (int X = 0; X < W; X++)
{
float AO = R.ReadSingle();
ImageUtility.float4 Color = new ImageUtility.float4(AO, AO, AO, AO);
Color = m_ProfileLinear.RGB2XYZ(Color);
m_BitmapResult.ContentXYZ[X, Y] = Color;
}
}
Pixels.Dispose();
m_TextureTarget_CPU.UnMap(0, 0);
// Assign result
viewportPanelResult.Image = m_BitmapResult;
} catch (Exception _e) {
MessageBox("An error occurred during generation!\r\n\r\nDetails: ", _e);
} finally {
panelParameters.Enabled = true;
}
}
private void LoadNormalMap(System.IO.FileInfo _FileName)
{
try {
// Dispose of existing resources
if (m_BitmapSourceNormal != null)
{
m_BitmapSourceNormal.Dispose();
}
m_BitmapSourceNormal = null;
if (m_TextureSourceNormal != null)
{
m_TextureSourceNormal.Dispose();
}
m_TextureSourceNormal = null;
// Load the source image assuming it's in linear space (all normal maps should be in linear space, with the default value being (0.5, 0.5, 1))
m_BitmapSourceNormal = new ImageUtility.Bitmap(_FileName, m_ProfileLinear);
// outputPanelInputHeightMap.Image = m_BitmapSourceNormal;
int W = m_BitmapSourceNormal.Width;
int H = m_BitmapSourceNormal.Height;
// Build the source texture
ImageUtility.float4[,] ContentRGB = m_BitmapSourceNormal.ConvertedContentRGB;
RendererManaged.PixelsBuffer SourceNormalMap = new RendererManaged.PixelsBuffer(W * H * 4 * 4);
using (System.IO.BinaryWriter Wr = SourceNormalMap.OpenStreamWrite())
for (int Y = 0; Y < H; Y++)
{
for (int X = 0; X < W; X++)
{
float Nx = 2.0f * ContentRGB[X, Y].x - 1.0f;
float Ny = 1.0f - 2.0f * ContentRGB[X, Y].y;
float Nz = 2.0f * ContentRGB[X, Y].z - 1.0f;
Wr.Write(Nx);
Wr.Write(Ny);
Wr.Write(Nz);
Wr.Write(1.0f);
}
}
m_TextureSourceNormal = new RendererManaged.Texture2D(m_Device, W, H, 1, 1, RendererManaged.PIXEL_FORMAT.RGBA32_FLOAT, false, false, new RendererManaged.PixelsBuffer[] { SourceNormalMap });
} catch (Exception _e) {
MessageBox("An error occurred while opening the image:\n\n", _e);
}
}
private void buttonClearNormalMap_Click(object sender, EventArgs e)
{
if (m_TextureSourceNormal != null)
{
m_TextureSourceNormal.Dispose();
}
// Create the default, planar normal map
RendererManaged.PixelsBuffer SourceNormalMap = new RendererManaged.PixelsBuffer(4 * 4);
using (System.IO.BinaryWriter Wr = SourceNormalMap.OpenStreamWrite()) {
Wr.Write(0.0f);
Wr.Write(0.0f);
Wr.Write(1.0f);
Wr.Write(1.0f);
}
m_TextureSourceNormal = new RendererManaged.Texture2D(m_Device, 1, 1, 1, 1, RendererManaged.PIXEL_FORMAT.RGBA32_FLOAT, false, false, new RendererManaged.PixelsBuffer[] { SourceNormalMap });
}
/// <summary>
/// Creates a 2D texture from the image
/// </summary>
/// <returns></returns>
public RendererManaged.Texture2D CreateTexture2D( RendererManaged.Device _Device )
{
if ( m_Opts.m_type != ImageOptions.TYPE.TT_2D )
throw new Exception( "The image is not a 2D texture!" );
RendererManaged.PIXEL_FORMAT TextureFormat = m_Opts.m_format.EquivalentRendererFormat;
uint ArraySize = m_Opts.m_arraySize;
uint MipsCount = m_Opts.m_curNumLevels;
uint PixelSize = m_Opts.m_format.BitsCount >> 3;
List<RendererManaged.PixelsBuffer> Content = new List<RendererManaged.PixelsBuffer>();
for ( uint SliceIndex=0; SliceIndex < ArraySize; SliceIndex++ ) {
for ( uint MipLevelIndex=0; MipLevelIndex < MipsCount; MipLevelIndex++ ) {
ImageSlice Slice = m_Slices[MipLevelIndex*ArraySize+SliceIndex]; // Stupidly stored in reverse order!
RendererManaged.PixelsBuffer Pixels = new RendererManaged.PixelsBuffer( (int) (Slice.m_Width * Slice.m_Height * PixelSize) );
Content.Add( Pixels );
using ( BinaryWriter Writer = Pixels.OpenStreamWrite() )
Writer.Write( Slice.m_Content );
}
}
RendererManaged.Texture2D Result = new RendererManaged.Texture2D( _Device, (int) m_Opts.m_curWidth, (int) m_Opts.m_curHeight, (int) m_Opts.m_arraySize, (int) m_Opts.m_curNumLevels, TextureFormat, false, false, Content.ToArray() );
return Result;
}
private void Generate()
{
try {
panelParameters.Enabled = false;
//////////////////////////////////////////////////////////////////////////
// 1] Apply bilateral filtering to the input texture as a pre-process
ApplyBilateralFiltering(m_TextureSource, m_TextureTarget0, floatTrackbarControlBilateralRadius.Value, floatTrackbarControlBilateralTolerance.Value, checkBoxWrap.Checked, BILATERAL_PROGRESS);
//////////////////////////////////////////////////////////////////////////
// 2] Compute directional occlusion
m_TextureTarget1.RemoveFromLastAssignedSlots();
// Prepare computation parameters
m_TextureTarget0.SetCS(0);
m_TextureTarget1.SetCSUAV(0);
m_SB_Rays.SetInput(1);
m_TextureSourceNormal.SetCS(2);
m_CB_Input.m.RaysCount = (UInt32)Math.Min(MAX_THREADS, integerTrackbarControlRaysCount.Value);
m_CB_Input.m.MaxStepsCount = (UInt32)integerTrackbarControlMaxStepsCount.Value;
m_CB_Input.m.Tile = (uint)(checkBoxWrap.Checked ? 1 : 0);
m_CB_Input.m.TexelSize_mm = TextureSize_mm / Math.Max(W, H);
m_CB_Input.m.Displacement_mm = TextureHeight_mm;
// Start
if (!m_CS_GenerateSSBumpMap.Use())
{
throw new Exception("Can't generate self-shadowed bump map as compute shader failed to compile!");
}
int h = Math.Max(1, MAX_LINES * 1024 / W);
int CallsCount = (int)Math.Ceiling((float)H / h);
for (int i = 0; i < CallsCount; i++)
{
m_CB_Input.m.Y0 = (UInt32)(i * h);
m_CB_Input.UpdateData();
m_CS_GenerateSSBumpMap.Dispatch(W, h, 1);
m_Device.Present(true);
progressBar.Value = (int)(0.01f * (BILATERAL_PROGRESS + (100 - BILATERAL_PROGRESS) * (i + 1) / (CallsCount)) * progressBar.Maximum);
// for ( int a=0; a < 10; a++ )
Application.DoEvents();
}
m_TextureTarget1.RemoveFromLastAssignedSlotUAV(); // So we can use it as input for next stage
progressBar.Value = progressBar.Maximum;
// Compute in a single shot (this is madness!)
// m_CB_Input.m.y = 0;
// m_CB_Input.UpdateData();
// m_CS_GenerateSSBumpMap.Dispatch( W, H, 1 );
//////////////////////////////////////////////////////////////////////////
// 3] Copy target to staging for CPU readback and update the resulting bitmap
m_TextureTarget_CPU.CopyFrom(m_TextureTarget1);
ImageUtility.ColorProfile Profile = m_ProfilesRGB; // AO maps are sRGB! (although strange, that's certainly to have more range in dark values)
if (m_BitmapResult != null)
{
m_BitmapResult.Dispose();
}
m_BitmapResult = null;
m_BitmapResult = new ImageUtility.Bitmap(W, H, Profile);
m_BitmapResult.HasAlpha = false;
RendererManaged.PixelsBuffer Pixels = m_TextureTarget_CPU.Map(0, 0);
using (System.IO.BinaryReader R = Pixels.OpenStreamRead())
for (int Y = 0; Y < H; Y++)
{
R.BaseStream.Position = Y * Pixels.RowPitch;
for (int X = 0; X < W; X++)
{
float AO = R.ReadSingle(); // Linear value
ImageUtility.float4 Color = new ImageUtility.float4(AO, AO, AO, AO);
Color = Profile.RGB2XYZ(Color); // Now sRGB value, converted as XYZ
m_BitmapResult.ContentXYZ[X, Y] = Color;
}
}
Pixels.Dispose();
m_TextureTarget_CPU.UnMap(0, 0);
// Assign result
viewportPanelResult.Image = m_BitmapResult;
} catch (Exception _e) {
MessageBox("An error occurred during generation!\r\n\r\nDetails: ", _e);
} finally {
panelParameters.Enabled = true;
}
}
private void LoadHeightMap(System.IO.FileInfo _FileName)
{
try {
panelParameters.Enabled = false;
// Dispose of existing resources
if (m_BitmapSource != null)
{
m_BitmapSource.Dispose();
}
m_BitmapSource = null;
if (m_TextureTarget_CPU != null)
{
m_TextureTarget_CPU.Dispose();
}
m_TextureTarget_CPU = null;
if (m_TextureTarget0 != null)
{
m_TextureTarget0.Dispose();
}
m_TextureTarget0 = null;
if (m_TextureTarget1 != null)
{
m_TextureTarget1.Dispose();
}
m_TextureTarget1 = null;
if (m_TextureSource != null)
{
m_TextureSource.Dispose();
}
m_TextureSource = null;
// Load the source image assuming it's in linear space
m_SourceFileName = _FileName;
m_BitmapSource = new ImageUtility.Bitmap(_FileName, m_ProfileLinear);
outputPanelInputHeightMap.Image = m_BitmapSource;
W = m_BitmapSource.Width;
H = m_BitmapSource.Height;
// Build the source texture
RendererManaged.PixelsBuffer SourceHeightMap = new RendererManaged.PixelsBuffer(W * H * 4);
using (System.IO.BinaryWriter Wr = SourceHeightMap.OpenStreamWrite())
for (int Y = 0; Y < H; Y++)
{
for (int X = 0; X < W; X++)
{
Wr.Write(m_BitmapSource.ContentXYZ[X, Y].y);
}
}
m_TextureSource = new RendererManaged.Texture2D(m_Device, W, H, 1, 1, RendererManaged.PIXEL_FORMAT.R32_FLOAT, false, false, new RendererManaged.PixelsBuffer[] { SourceHeightMap });
// Build the target UAV & staging texture for readback
m_TextureTarget0 = new RendererManaged.Texture2D(m_Device, W, H, 1, 1, RendererManaged.PIXEL_FORMAT.R32_FLOAT, false, true, null);
m_TextureTarget1 = new RendererManaged.Texture2D(m_Device, W, H, 1, 1, RendererManaged.PIXEL_FORMAT.R32_FLOAT, false, true, null);
m_TextureTarget_CPU = new RendererManaged.Texture2D(m_Device, W, H, 1, 1, RendererManaged.PIXEL_FORMAT.R32_FLOAT, true, false, null);
panelParameters.Enabled = true;
buttonGenerate.Focus();
} catch (Exception _e) {
MessageBox("An error occurred while opening the image:\n\n", _e);
}
}
