/// <summary> /// Loads a texture from an image in memory. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "memory">Array of memory containing the image data to load.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static Resource FromMemory(Device device, byte[] memory, ImageLoadInformation loadInfo) { unsafe { System.Diagnostics.Debug.Assert(memory != null); System.Diagnostics.Debug.Assert(memory.Length > 0); IntPtr temp; Result resultOut; fixed(void *pBuffer = &memory[0]) D3DX11.CreateTextureFromMemory(device, (IntPtr)pBuffer, memory.Length, loadInfo, IntPtr.Zero, out temp, out resultOut); var resource = new Resource(temp); try { switch (resource.Dimension) { case ResourceDimension.Texture1D: return(FromPointer <Texture1D>(temp)); case ResourceDimension.Texture2D: return(FromPointer <Texture2D>(temp)); case ResourceDimension.Texture3D: return(FromPointer <Texture3D>(temp)); } } finally { resource.NativePointer = IntPtr.Zero; } return(null); } }
/// <summary> /// Loads a texture from an image in memory. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "pointer">Pointer to unmanaged memory containing the image data to load.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static Resource FromMemory(Device device, DataPointer pointer, ImageLoadInformation loadInfo) { System.Diagnostics.Debug.Assert(pointer.Pointer != IntPtr.Zero); System.Diagnostics.Debug.Assert(pointer.Size > 0); IntPtr temp; Result resultOut; D3DX11.CreateTextureFromMemory(device, pointer.Pointer, pointer.Size, loadInfo, IntPtr.Zero, out temp, out resultOut); var resource = new Resource(temp); try { switch (resource.Dimension) { case ResourceDimension.Texture1D: return(FromPointer <Texture1D>(temp)); case ResourceDimension.Texture2D: return(FromPointer <Texture2D>(temp)); case ResourceDimension.Texture3D: return(FromPointer <Texture3D>(temp)); } } finally { resource.NativePointer = IntPtr.Zero; } return(null); }
/// <summary> /// Loads a texture from an image file. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "fileName">Path to the file on disk.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static Resource FromFile(Device device, string fileName, ImageLoadInformation loadInfo) { IntPtr temp; Result resultOut; D3DX11.CreateTextureFromFile(device, fileName, loadInfo, IntPtr.Zero, out temp, out resultOut); var resource = new Resource(temp); try { switch (resource.Dimension) { case ResourceDimension.Texture1D: return(FromPointer <Texture1D>(temp)); case ResourceDimension.Texture2D: return(FromPointer <Texture2D>(temp)); case ResourceDimension.Texture3D: return(FromPointer <Texture3D>(temp)); } } finally { resource.NativePointer = IntPtr.Zero; } return(null); }
/// <summary> /// Create a shader-resource view from a file. /// </summary> /// <param name="device">A reference to the device (see <see cref="SharpDX.Direct3D11.Device"/>) that will use the resource. </param> /// <param name="fileName">Name of the file that contains the shader-resource view.</param> /// <param name="loadInformation">Identifies the characteristics of a texture (see <see cref="SharpDX.Direct3D11.ImageLoadInformation"/>) when the data processor is created. </param> /// <returns>Returns a reference to the shader-resource view (see <see cref="SharpDX.Direct3D11.ShaderResourceView"/>). </returns> /// <unmanaged>HRESULT D3DX11CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult)</unmanaged> public static ShaderResourceView FromFile(Device device, string fileName, ImageLoadInformation loadInformation) { ShaderResourceView temp; Result hResult; D3DX11.CreateShaderResourceViewFromFile(device, fileName, loadInformation, IntPtr.Zero, out temp, out hResult); // TODO test hResult? return temp; }
/// <summary> /// Create a shader-resource view from a file. /// </summary> /// <param name="device">A reference to the device (see <see cref="SharpDX.Direct3D11.Device"/>) that will use the resource. </param> /// <param name="fileName">Name of the file that contains the shader-resource view.</param> /// <param name="loadInformation">Identifies the characteristics of a texture (see <see cref="SharpDX.Direct3D11.ImageLoadInformation"/>) when the data processor is created. </param> /// <returns>Returns a reference to the shader-resource view (see <see cref="SharpDX.Direct3D11.ShaderResourceView"/>). </returns> /// <unmanaged>HRESULT D3DX11CreateShaderResourceViewFromFileW([None] ID3D10Device* pDevice,[None] const wchar_t* pSrcFile,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult)</unmanaged> public static ShaderResourceView FromFile(Device device, string fileName, ImageLoadInformation loadInformation) { ShaderResourceView temp; Result hResult; D3DX11.CreateShaderResourceViewFromFile(device, fileName, loadInformation, IntPtr.Zero, out temp, out hResult); // TODO test hResult? return(temp); }
/// <summary> /// Loads a texture from an image file. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "fileName">Path to the file on disk.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static T FromFile <T>(Device device, string fileName, ImageLoadInformation loadInfo) where T : Resource { System.Diagnostics.Debug.Assert(typeof(T) == typeof(Texture1D) || typeof(T) == typeof(Texture2D) || typeof(T) == typeof(Texture3D)); IntPtr temp; Result resultOut; D3DX11.CreateTextureFromFile(device, fileName, loadInfo, IntPtr.Zero, out temp, out resultOut); return(FromPointer <T>(temp)); }
/// <summary> /// Create a shader-resource view from a file in memory. /// </summary> /// <param name="device">A reference to the device (see <see cref="SharpDX.Direct3D11.Device"/>) that will use the resource. </param> /// <param name="memory">Pointer to a memory location that contains the shader-resource view. </param> /// <param name="loadInformation">Identifies the characteristics of a texture (see <see cref="SharpDX.Direct3D11.ImageLoadInformation"/>) when the data processor is created. </param> /// <returns>Returns a reference to the shader-resource view (see <see cref="SharpDX.Direct3D11.ShaderResourceView"/>). </returns> /// <unmanaged>HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult)</unmanaged> public static ShaderResourceView FromMemory(Device device, byte[] memory, ImageLoadInformation loadInformation) { unsafe { ShaderResourceView temp; Result hResult; fixed(void *pMemory = &memory[0]) D3DX11.CreateShaderResourceViewFromMemory(device, new IntPtr(pMemory), memory.Length, loadInformation, IntPtr.Zero, out temp, out hResult); // TODO test hResult? return(temp); } }
/// <summary> /// Loads a texture from an image in memory. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "pointer">Pointer to unmanaged memory containing the image data to load.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static T FromMemory <T>(Device device, DataPointer pointer, ImageLoadInformation loadInfo) where T : Resource { System.Diagnostics.Debug.Assert(typeof(T) == typeof(Texture1D) || typeof(T) == typeof(Texture2D) || typeof(T) == typeof(Texture3D)); System.Diagnostics.Debug.Assert(pointer.Pointer != IntPtr.Zero); System.Diagnostics.Debug.Assert(pointer.Size > 0); IntPtr temp; Result resultOut; D3DX11.CreateTextureFromMemory(device, pointer.Pointer, pointer.Size, loadInfo, IntPtr.Zero, out temp, out resultOut); return(FromPointer <T>(temp)); }
/// <summary> /// Loads a texture from an image in memory. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "memory">Array of memory containing the image data to load.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static T FromMemory <T>(Device device, byte[] memory, ImageLoadInformation loadInfo) where T : Resource { System.Diagnostics.Debug.Assert(typeof(T) == typeof(Texture1D) || typeof(T) == typeof(Texture2D) || typeof(T) == typeof(Texture3D)); unsafe { System.Diagnostics.Debug.Assert(memory != null); System.Diagnostics.Debug.Assert(memory.Length > 0); IntPtr temp; Result resultOut; fixed(void *pBuffer = &memory[0]) D3DX11.CreateTextureFromMemory(device, (IntPtr)pBuffer, memory.Length, loadInfo, IntPtr.Zero, out temp, out resultOut); return(FromPointer <T>(temp)); } }
/// <summary> /// Create a shader-resource view from a file in memory. /// </summary> /// <param name="device">A reference to the device (see <see cref="SharpDX.Direct3D11.Device"/>) that will use the resource. </param> /// <param name="memory">Pointer to a memory location that contains the shader-resource view. </param> /// <param name="loadInformation">Identifies the characteristics of a texture (see <see cref="SharpDX.Direct3D11.ImageLoadInformation"/>) when the data processor is created. </param> /// <returns>Returns a reference to the shader-resource view (see <see cref="SharpDX.Direct3D11.ShaderResourceView"/>). </returns> /// <unmanaged>HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult)</unmanaged> public static ShaderResourceView FromMemory(Device device, byte[] memory, ImageLoadInformation loadInformation) { unsafe { ShaderResourceView temp; Result hResult; fixed (void* pMemory = &memory[0]) D3DX11.CreateShaderResourceViewFromMemory(device, new IntPtr(pMemory), memory.Length, loadInformation, IntPtr.Zero, out temp, out hResult); // TODO test hResult? return temp; } }
public static Texture11 FromBitmap(Device device, Bitmap bmp) { var ms = new MemoryStream(); bmp.Save(ms, ImageFormat.Png); ms.Seek(0, SeekOrigin.Begin); if (IsPowerOf2((uint)bmp.Width) && IsPowerOf2((uint)bmp.Height)) { var loadInfo = new ImageLoadInformation(); loadInfo.BindFlags = BindFlags.ShaderResource; loadInfo.CpuAccessFlags = CpuAccessFlags.None; loadInfo.Depth = -1; loadInfo.Format = RenderContext11.DefaultTextureFormat; loadInfo.Filter = FilterFlags.Box; loadInfo.FirstMipLevel = 0; loadInfo.Height = -1; loadInfo.MipFilter = FilterFlags.Linear; loadInfo.MipLevels = 0; loadInfo.OptionFlags = ResourceOptionFlags.None; loadInfo.Usage = ResourceUsage.Default; loadInfo.Width = -1; if (loadInfo.Format == Format.R8G8B8A8_UNorm_SRgb) { loadInfo.Filter |= FilterFlags.SRgb; } var texture = Texture2D.FromStream<Texture2D>(device, ms, (int)ms.Length, loadInfo); ms.Dispose(); return new Texture11(texture); } else { ms.Seek(0, SeekOrigin.Begin); var ili = new ImageLoadInformation() { BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Depth = -1, Filter = FilterFlags.Box, FirstMipLevel = 0, Format = RenderContext11.DefaultTextureFormat, Height = -1, MipFilter = FilterFlags.None, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, Usage = ResourceUsage.Default, Width = -1 }; if (ili.Format == Format.R8G8B8A8_UNorm_SRgb) { ili.Filter |= FilterFlags.SRgb; } var texture = Texture2D.FromStream<Texture2D>(device, ms, (int)ms.Length, ili); ms.Dispose(); return new Texture11(texture); } }
public static Texture11 FromStream(Device device, Stream stream) { try { var loadInfo = new ImageLoadInformation(); loadInfo.BindFlags = BindFlags.ShaderResource; loadInfo.CpuAccessFlags = CpuAccessFlags.None; loadInfo.Depth = -1; loadInfo.Format = RenderContext11.DefaultTextureFormat; loadInfo.Filter = FilterFlags.Box; loadInfo.FirstMipLevel = 0; loadInfo.Height = -1; loadInfo.MipFilter = FilterFlags.Linear; loadInfo.MipLevels = 0; loadInfo.OptionFlags = ResourceOptionFlags.None; loadInfo.Usage = ResourceUsage.Default; loadInfo.Width = -1; if (loadInfo.Format == Format.R8G8B8A8_UNorm_SRgb) { loadInfo.Filter |= FilterFlags.SRgb; } var texture = Texture2D.FromStream<Texture2D>(device, stream, (int)stream.Length, loadInfo); return new Texture11(texture); } catch { return null; } }
public static Texture11 FromFile(Device device, string fileName, LoadOptions options = LoadOptions.AssumeSRgb) { try { var loadInfo = new ImageLoadInformation(); loadInfo.BindFlags = BindFlags.ShaderResource; loadInfo.CpuAccessFlags = CpuAccessFlags.None; loadInfo.Depth = -1; loadInfo.Filter = FilterFlags.Box; loadInfo.FirstMipLevel = 0; loadInfo.Format = Format.R8G8B8A8_UNorm; loadInfo.Height = -1; loadInfo.MipLevels = -1; loadInfo.OptionFlags = ResourceOptionFlags.None; loadInfo.Usage = ResourceUsage.Default; loadInfo.Width = -1; var shouldPromoteSRgb = RenderContext11.sRGB && (options & LoadOptions.AssumeSRgb) == LoadOptions.AssumeSRgb; if (fileName.EndsWith(".png", StringComparison.InvariantCultureIgnoreCase) || fileName.EndsWith(".jpg", StringComparison.InvariantCultureIgnoreCase) || fileName.EndsWith(".jpeg", StringComparison.InvariantCultureIgnoreCase)) { loadInfo.Filter = FilterFlags.Box; if (shouldPromoteSRgb) { loadInfo.Format = promoteFormatToSRGB(loadInfo.Format); } if (isSRGBFormat(loadInfo.Format)) { loadInfo.Filter |= FilterFlags.SRgb; } } else { // Promote image format to sRGB var info = ImageInformation.FromFile(fileName); if (info.HasValue && shouldPromoteSRgb) { loadInfo.Format = promoteFormatToSRGB(info.Value.Format); } if (isSRGBFormat(loadInfo.Format) ) { loadInfo.Filter |= FilterFlags.SRgb; } } var texture = Texture2D.FromFile<Texture2D>(device, fileName, loadInfo); return new Texture11(texture); } catch (Exception e) { try { var ili = new ImageLoadInformation() { BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Depth = -1, Filter = FilterFlags.Box, FirstMipLevel = 0, Format = RenderContext11.DefaultTextureFormat, Height = -1, MipFilter = FilterFlags.None, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, Usage = ResourceUsage.Default, Width = -1 }; if (ili.Format == Format.R8G8B8A8_UNorm_SRgb) { ili.Filter |= FilterFlags.SRgb; } var texture = Texture2D.FromFile<Texture2D>(device, fileName, ili); return new Texture11(texture); } catch { return null; } } }
/// <summary> /// Create a shader-resource view from a file in a stream.. /// </summary> /// <param name="device">A reference to the device (see <see cref="SharpDX.Direct3D11.Device"/>) that will use the resource. </param> /// <param name="stream">Pointer to the file in memory that contains the shader-resource view. </param> /// <param name="sizeInBytes">Size of the file to read from the stream</param> /// <param name="loadInformation">Identifies the characteristics of a texture (see <see cref="SharpDX.Direct3D11.ImageLoadInformation"/>) when the data processor is created. </param> /// <returns>Returns a reference to the shader-resource view (see <see cref="SharpDX.Direct3D11.ShaderResourceView"/>). </returns> /// <unmanaged>HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult)</unmanaged> public static ShaderResourceView FromStream(Device device, Stream stream, int sizeInBytes, ImageLoadInformation loadInformation) { byte[] memory = Utilities.ReadStream(stream, ref sizeInBytes); return(FromMemory(device, memory, loadInformation)); }
/// <summary> /// Adds a resource to the proxy, with specific loading information. /// </summary> /// <param name="name">The resource name.</param> /// <param name="loadInformation">Image loading information.</param> public void AddResource(String name, ImageLoadInformation loadInformation) { references.Add(name, new ResourceReference(Device, Resource.FromFile(Device, name, loadInformation))); }
/// <summary> /// Create a shader-resource view from a file in a stream.. /// </summary> /// <param name="device">A reference to the device (see <see cref="SharpDX.Direct3D11.Device"/>) that will use the resource. </param> /// <param name="stream">Pointer to the file in memory that contains the shader-resource view. </param> /// <param name="sizeInBytes">Size of the file to read from the stream</param> /// <param name="loadInformation">Identifies the characteristics of a texture (see <see cref="SharpDX.Direct3D11.ImageLoadInformation"/>) when the data processor is created. </param> /// <returns>Returns a reference to the shader-resource view (see <see cref="SharpDX.Direct3D11.ShaderResourceView"/>). </returns> /// <unmanaged>HRESULT D3DX11CreateShaderResourceViewFromMemory([None] ID3D10Device* pDevice,[None] const void* pSrcData,[None] SIZE_T SrcDataSize,[In, Optional] D3DX11_IMAGE_LOAD_INFO* pLoadInfo,[None] ID3DX11ThreadPump* pPump,[None] ID3D10ShaderResourceView** ppShaderResourceView,[None] HRESULT* pHResult)</unmanaged> public static ShaderResourceView FromStream(Device device, Stream stream, int sizeInBytes, ImageLoadInformation loadInformation) { byte[] memory = Utilities.ReadStream(stream, ref sizeInBytes); return FromMemory(device, memory, loadInformation); }
/// <summary> /// Loads a texture from a stream of data. /// </summary> /// <param name = "device">The device used to load the texture.</param> /// <param name = "stream">A stream containing the image data to load.</param> /// <param name = "sizeInBytes">Size of the image to load.</param> /// <param name = "loadInfo">Specifies information used to load the texture.</param> /// <returns>The loaded texture object.</returns> public static Resource FromStream(Device device, Stream stream, int sizeInBytes, ImageLoadInformation loadInfo) { byte[] buffer = Utilities.ReadStream(stream, ref sizeInBytes); return(FromMemory(device, buffer, loadInfo)); }
//bmp > tga > png > dds //public byte[] ReadFile(string file) //{ // try // { // byte[] fBytes = File.ReadAllBytes(file); // if (fBytes.Length == 0) // { // switch (Path.GetExtension(file).ToLowerInvariant()) // { // case "bmp": // return ReadFile(Path.ChangeExtension(file, "tga")); // case "tga": // return ReadFile(Path.ChangeExtension(file, "png")); // case "png": // return ReadFile(Path.ChangeExtension(file, "dds")); // //case "dds": // //default: // } // } // } // catch (IOException e) // { // Trace.TraceError(e.ToString()); // } // return null; //} private JobResult _process(Job job, Recovery recovery, bool asMappable = true) { string file = job.Key; byte[] fBytes = job.Value; int fLen = fBytes.Length; Result code = Result.NoAction; byte[] output = null; using (var ms = new MemoryStream(fBytes)) try { var txFlags = asMappable ? SharpDX.Toolkit.Graphics.TextureFlags.RenderTarget : SharpDX.Toolkit.Graphics.TextureFlags.ShaderResource; bool cube = file.Contains("\\cubemaps\\"); Texture tex; if (cube) tex = SharpDX.Toolkit.Graphics.TextureCube.Load(_device, ms, txFlags, ResourceUsage.Default); else tex = SharpDX.Toolkit.Graphics.Texture2D.Load(_device, ms, txFlags, ResourceUsage.Default); using (tex) { if (tex.Description.BindFlags.HasFlag(BindFlags.RenderTarget | BindFlags.ShaderResource) && tex.Description.MipLevels > 1) { Trace.TraceInformation("Generating mipmaps..."); tex.GenerateMipMaps(); code |= Result.GeneratedMipmaps; } if (!tex.IsBlockCompressed) { Console.WriteLine(tex.Description.Format); //var loadOpts = new ImageLoadInformation() //{ // //Format = SharpDX.DXGI.Format.bc3, //}; var desc = tex.Description; var loadOpts = new ImageLoadInformation { BindFlags = desc.BindFlags, CpuAccessFlags = desc.CpuAccessFlags, Depth = desc.Depth, Filter = FilterFlags.None, //FirstMipLevel = desc.MipLevels,// 0, Format = desc.Format,//SharpDX.DXGI.Format.BC3_UNorm_SRgb, Height = tex.Height, Width = tex.Width, MipFilter = FilterFlags.Box, MipLevels = desc.MipLevels, OptionFlags = desc.OptionFlags, //PSrcInfo = new IntPtr(&imginf), Usage = desc.Usage, }; ms.Seek(0, SeekOrigin.Begin); System.Diagnostics.Trace.Assert(tex.GetType() == typeof(SharpDX.Toolkit.Graphics.Texture2D)); System.Diagnostics.Trace.Assert(!cube); //using (var newTex = SharpDX.Direct3D11.Texture2D.FromStream(_device, ms, fLen))//, loadOpts)) using (var newTex = SharpDX.Toolkit.Graphics.Texture2D.Load(_device, ms, txFlags, ResourceUsage.Default))//(_device, ms, fLen))//, loadOpts)) { using (var msNew = new MemoryStream()) { SharpDX.Direct3D11.Texture2D.ToStream(_device, newTex, ImageFileFormat.Dds, msNew); File.Copy(file, recovery.GetBackupPath(Path.GetFileNameWithoutExtension(file) + "_orig.dds")); //recovery.Backup(file); output = msNew.ToArray(); } Trace.TraceInformation(Path.GetFileNameWithoutExtension(file) + " converted to BC3"); code |= Result.CompressedBC3; } } } } catch (SharpDXException sdx) { if (asMappable) return _process(job, recovery, false); Trace.TraceError(sdx.ToString()); code = Result.Failed; } catch (NullReferenceException nre) { Trace.TraceError(nre.ToString()); code = Result.Failed; } return new JobResult(recovery.GetBackupPath(file), code, output); }
private void CompileButton_Click(object sender, RoutedEventArgs e) { //make the width and height flexible if (paths.Count > 2 && redIndex > -1 && greenIndex > -1 && blueIndex > -1) { Device d = new Device(SharpDX.Direct3D.DriverType.Hardware); ImageLoadInformation loadInfo = new ImageLoadInformation() { BindFlags = BindFlags.None, CpuAccessFlags = CpuAccessFlags.Read, Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm, OptionFlags = ResourceOptionFlags.None, Usage = ResourceUsage.Staging }; Texture2D red, green, blue,final; red = Texture2D.FromFile<Texture2D>(d,paths[redIndex],loadInfo); green = Texture2D.FromFile<Texture2D>(d, paths[greenIndex],loadInfo); blue = Texture2D.FromFile<Texture2D>(d, paths[blueIndex],loadInfo); final = new Texture2D(d, new Texture2DDescription() { ArraySize = 1, BindFlags = BindFlags.None, CpuAccessFlags = CpuAccessFlags.Write, Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm, Height = 3456, MipLevels = 0, OptionFlags = ResourceOptionFlags.None, SampleDescription = new SharpDX.DXGI.SampleDescription(1,0), Usage = ResourceUsage.Staging, Width = 4608 }); DataBox redDataBox = d.ImmediateContext.MapSubresource(red,0,MapMode.Read,MapFlags.None); DataBox greenDataBox = d.ImmediateContext.MapSubresource(green, 0, MapMode.Read, MapFlags.None); DataBox blueDataBox = d.ImmediateContext.MapSubresource(blue, 0, MapMode.Read, MapFlags.None); DataBox finalDataBox = d.ImmediateContext.MapSubresource(final, 0, MapMode.Write, MapFlags.None); byte[] redData = new byte[redDataBox.RowPitch * red.Description.Height], greenData = new byte[greenDataBox.RowPitch * green.Description.Height], blueData =new byte[blueDataBox.RowPitch * blue.Description.Height], finalData = new byte[finalDataBox.RowPitch * final.Description.Height]; Utilities.Read(redDataBox.DataPointer, redData, 0, redData.Length); Utilities.Read(greenDataBox.DataPointer, greenData, 0, greenData.Length); Utilities.Read(blueDataBox.DataPointer, blueData, 0, blueData.Length); for (int x = 0; x < final.Description.Width; x++) { for (int y = 0; y < final.Description.Height; y++) { int index = (x*4) + (y * finalDataBox.RowPitch); finalData[index] = redData[index]; finalData[index + 1] = greenData[index]; finalData[index + 2] = blueData[index]; finalData[index + 3] = 255;//A } } Utilities.Write(finalDataBox.DataPointer, finalData, 0, finalData.Length); d.ImmediateContext.UnmapSubresource(red, 0); d.ImmediateContext.UnmapSubresource(green, 0); d.ImmediateContext.UnmapSubresource(blue, 0); d.ImmediateContext.UnmapSubresource(final, 0); Texture2D.ToFile(d.ImmediateContext, final, ImageFileFormat.Png, "C:\\dan\\projectmedia\\BumpMap\\final.png"); final.Dispose(); red.Dispose(); green.Dispose(); blue.Dispose(); d.Dispose(); } else MessageBox.Show("must choose at least 3 files and select 3 to be the red green and blue channels"); }