Loading textures

[Gavin-Williams]

I've been at it for several hours now, my old SharpDX code doesn't seem to translate. And the C++ example code is 800 lines. So I'm giving up, and asking. Does anyone have some code to load a png into a texture2d?

[Gavin-Williams]

Here's what I have, but as you can see, there are things missing, because many of my helper functions don't work anymore.

    public static Texture LoadSDRTexture(FileInfo file)
    {
        file.OpenRead();
        Texture texture = null;
        ID3D11Texture2D1 texture2d;
        if (file.Extension == ".dds")
        {
            throw new NotImplementedException();
            ////StorageFile file = await Package.Current.InstalledLocation.GetFileAsync(job.File.Path);
            //NativeFileStream stream = new NativeFileStream(file.Path, NativeFileMode.Open, NativeFileAccess.Read);
            //ResourceUsage usage = ResourceUsage.Default;
            //bool useMipMaps = false;
            //texture2d = CreateTexture2DFromDDSStream(device, usage, stream, useMipMaps, false);
            //stream.Dispose();
        }
        else if (file.Extension == ".bmp" || file.Extension == ".png")
        {
            //BitmapSource bmSource = GetBitmapSource(file.Path, dx11.FactoryWIC);

            BitmapImage bmImage = new BitmapImage(
                new Uri(file.ToString(), UriKind.RelativeOrAbsolute));

            SubresourceData[] data = new SubresourceData[]
                {
                    bmImage
                }

            Texture2DDescription1 desc = new Texture2DDescription1()
            {
                Width = bmSource.PixelWidth,
                Height = bmSource.PixelHeight,
                ArraySize = 1,
                MipLevels = 1,
                CpuAccessFlags = CpuAccessFlags.None,
                BindFlags = BindFlags.ShaderResource,
                Format = Vortice.DXGI.Format.R8G8B8A8_UNorm,
                OptionFlags = ResourceOptionFlags.None,
                SampleDescription = new Vortice.DXGI.SampleDescription(1, 0),
                TextureLayout = TextureLayout.Undefined,
                Usage = ResourceUsage.Default
            };
            //Texture2DFactory.CreateFromBitmapSource(bmSource, ResourceOptionFlags.None, ResourceUsage.Default, BindFlags.ShaderResource | BindFlags.RenderTarget
            texture2d = Gfx.Device3d.DxDevice.CreateTexture2D1(desc, data);
        }
        else
        {
            Debug.LogMessage("FileIo.LoadSDRTexture | Info: file is null.");
            texture = null;
        }
        texture = new Texture(texture2d);
    }

[Gavin-Williams]

I've copied that file to a solution folder. I've never used a file like that before. So I don't know what's meant to happen or how to use it. I checked this page...

https://docs.microsoft.com/en-us/nuget/reference/nuget-config-file

But it reads like I'm already meant to know what it means. There are no instructions on how to make such a file 'just work'.

[Gavin-Williams]

So today I moved the config file to the project instead of the solution folder. I can now update my nuget packages. But I had to update them in some order, and I've noticed this with Microsoft packages as well lately. Sometimes they won't even update. I haven't heard of others having the same problem

[Gavin-Williams]

Got your method working now. But I'm finding it pretty difficult to make an image that will load. It seems like Microsoft's recommended conversion's don't cover 24 bit images, which is the default output for Photoshop and and the likely format for any image found online. Even when I add an alpha channel and export as PNG, properties still show a 24 bit image. Photoshop will save a a 32 bit Bmp, which gets converted to B8G8R8X8_UNorm which I can work with.

[Gavin-Williams]

Crazy thing in Photoshop, even when I use the full PNG export tool, add an alpha channel and the transparency box is set. The image still exports as 24 bit.

[Kharzette]

I just recently ported mine and it seems to work if you want to look at it around line 1273: https://github.com/Kharzette/GrogLibs/blob/master/MaterialLib/StuffKeeper.cs?ts=4

LoadPNGWIC() loads it up. I premultiply alpha and convert to linear color space in there somewhere.

[h1cks]

@Gavin-Williams i use a load into a bitmap then translate the bitmap data to the format in Texture2d, Can dump code here (it's a bit verbose though)

This function is what im currently using, its a little inefficient but its a cut over from sharpdx days. Takes care of whether you want to create autogen mip maps

`
public static ID3D11Texture2D CreateTex2DFromBitmap(System.Drawing.Bitmap bsource, D3D11.ID3D11Device1 d3dDevice, D3D11.Texture2DDescription textureDesc)
{
ID3D11Texture2D t2d_ = null;

        try
        {
            int stride_ = bsource.Size.Width * 4;
            var buffer_ = new DataStream(bsource.Size.Height * stride_, true, true);

            if (textureDesc.MipLevels != 0)
            {
                t2d_ = d3dDevice.CreateTexture2D(textureDesc);

                byte[] pixelData_ = BitmapHelper.GetPixelData(bsource);

                SwapARGBtoABGR(ref pixelData_);

                for (int i = 0; i < pixelData_.Length; i++)
                {
                    buffer_.Write(pixelData_[i]);
                }

                buffer_.Position = 0;

                SubresourceData[] sData = new SubresourceData[1];

                sData[0] = new SubresourceData(buffer_.BasePointer, stride_, 0);
                                   
                t2d_ = d3dDevice.CreateTexture2D(textureDesc, sData);      
            }
            else
            {
                t2d_ = d3dDevice.CreateTexture2D(textureDesc); /// this creates a texture and populates it, we need to create a blank one then populate it.                

                var pixelData_ = BitmapHelper.GetPixelData(bsource);

                SwapARGBtoABGR(ref pixelData_);

                for (int i = 0; i < pixelData_.Length; i++)
                {
                    buffer_.Write(pixelData_[i]);
                }

                buffer_.Position = 0;
                MappedSubresource box_ = new MappedSubresource(buffer_.PositionPointer, stride_, 0);

                d3dDevice.ImmediateContext.UpdateSubresource(box_, t2d_, ID3D11Resource.CalculateSubResourceIndex(0, 0, CountMips(bsource.Size.Width, bsource.Size.Height)));
            }
            buffer_.Dispose();


        }
        catch (Exception ex_)
        {
            ErrorHandler.DoErrorHandling(ex_, ErrorHandler.GetCurrentMethod(ex_));

        }
        return t2d_;
    }

`

Let me know if you want the rest.

[Gavin-Williams]

Thank you! I should be able to use this and combined with my old code, it should be possible to work out all the variations - 24 bit, mip-maps etc. I've been flitting around the outskirts but I guess this week I will just have to get down into the code. If I remember correctly, this part isn't too bad, it's when I need to create a Texture2dArray or load a DDS that things start getting a little more complicated.

[h1cks]

I've also got the code to create texture arrays as well. this requires some finesse, especially if you want ot maintain the mipmaps.

You need to firstly load into a texture2d, then copy all textures for your array to a staging texture set then create the texture buffer in one call. This makes the buffer immutable in the GPU which in turn improves the performance of the texture array.

` public ID3D11ShaderResourceView CreateTextureArray(ID3D11Device1 d3dDevice, bool immutable)
{
TextureConfiguration currentTexture_ = null;

        List<ID3D11Texture2D> textureList_ = new List<ID3D11Texture2D>();
        try
        {
            if (_textureList.Count > 0)
            {
                Debug.Assert(_textureList[0].Configuration.LoadedDimensions.Width > 0);

                int mipLevels_ = _textureList[0].GetTexture2D().Description.MipLevels;

                // You need to generate a staging texture from the original texture loaded in, which means, you've loaded it once, you then move it to a staging...just 
                // so the staging can set the mipmap functionality.  You then need to take the staging textures, and load them into an array.  Because, you can use the original texture
                // as its not staged. All the MIP MAP value of 0 does is get auto set to the nearest ^2 of the texture width.  so for 512, the mip is calculated internally at 10.
                D3D11.Texture2DDescription desc_ = new D3D11.Texture2DDescription()
                {
                    Width = (int)_textureList[0].Configuration.LoadedDimensions.Width,
                    Height = (int)_textureList[0].Configuration.LoadedDimensions.Height,
                    ArraySize = 1,
                    Usage = D3D11.ResourceUsage.Staging,
                    CpuAccessFlags = D3D11.CpuAccessFlags.Read,
                    Format = DirectXManager.SupportedBackbufferFormat,
                    MipLevels = mipLevels_,
                    OptionFlags = D3D11.ResourceOptionFlags.None,
                    SampleDescription = new SampleDescription(1, 0) ,
                    BindFlags = D3D11.BindFlags.None,
                };

                for (int i_ = 0; i_ < _textureList.Count; i_++)
                {
                    currentTexture_ = _textureList[i_].Configuration;

                    var t2d_  = d3dDevice.CreateTexture2D(desc_);

                    t2d_.DebugName = currentTexture_.TextureName;

                    string errorString_ = _textureList[i_].Configuration.FileName;

                    if (!currentTexture_.DataIsLoaded)
                    {
                        d3dDevice.ImmediateContext.CopyResource(t2d_, _textureList[0].GetTexture2D());
                    }
                    else
                    {
                        Debug.Assert(_textureList[i_].GetTexture2D() != null);

                        Debug.Assert(_textureList[i_].GetTexture2D().Description.Width == _textureList[0].GetTexture2D().Description.Width);
                        Debug.Assert(_textureList[i_].GetTexture2D().Description.Height == _textureList[0].GetTexture2D().Description.Height);

                        d3dDevice.ImmediateContext.CopyResource(t2d_, _textureList[i_].GetTexture2D());
                    }

                    textureList_.Add(t2d_);
                }

                var result_ = DirectXHelper.CreateTexture2DArraySRV(d3dDevice, textureList_, immutable);

                for (int i_ = 0; i_ < textureList_.Count; i_++)
                {
                    textureList_[i_].Dispose();
                }

                textureList_.Clear();

                return result_;
            }
        }
        catch (Exception ex_)
        {
            ErrorHandler.WriteTraceLog("Error on texture: " + currentTexture_?.TextureName);

            ErrorHandler.DoErrorHandling(ex_, currentTexture_?.TextureName + " - " + ErrorHandler.GetCurrentMethod(ex_));
        }

        return null;
    }`

[h1cks]

that creates the temporary texture array.

this call takes that array and creates the texture array

` //===============================================================================================================================//

    public static ID3D11ShaderResourceView CreateTexture2DArraySRV(D3D11.ID3D11Device1 d3dDevice, List<ID3D11Texture2D> sourceTextures, bool isImmutable)
    {
        ID3D11ShaderResourceView texArraySRV_ = null;

        try
        {
            var texElementDesc_ = sourceTextures[0].Description;

            ResourceUsage usage_;

            if (isImmutable)
                usage_ = ResourceUsage.Immutable;
            else
                usage_ = ResourceUsage.Default;

            var texArrayDesc_ = new D3D11.Texture2DDescription
            {
                Width = texElementDesc_.Width,
                Height = texElementDesc_.Height,
                MipLevels = texElementDesc_.MipLevels,
                ArraySize = sourceTextures.Count,
                Format = texElementDesc_.Format,
                SampleDescription = new DXGI.SampleDescription(1, 0),
                Usage = usage_,
                BindFlags = D3D11.BindFlags.ShaderResource,
                CpuAccessFlags = D3D11.CpuAccessFlags.None,
                OptionFlags = D3D11.ResourceOptionFlags.None,                    
            };

            // you can update a texture post creating it, but it means you cant set things like immutable on the texture.  As that can only be done at creation time.   Best to set up the data container andpass it at creation.
            // tip, if you want mipmapping, create it in the original texture, it is then copied into the staging texture which the CPU can then read, we then copy that into a databox that can be loaded in on initial creation, quadruple handling, but needed quin if you include load bitmap

            SubresourceData[] sSubData_ = new SubresourceData[sourceTextures.Count * texElementDesc_.MipLevels];
            for (int texElement_ = 0; texElement_ < sourceTextures.Count; texElement_++)
            {
                if (texElementDesc_.MipLevels == 1)
                {
                    Debug.Assert(true);
                }

                for (int mipLevel_ = 0; mipLevel_ < texElementDesc_.MipLevels; mipLevel_++)
                {
                    MappedSubresource subResource_ = d3dDevice.ImmediateContext.Map(sourceTextures[texElement_], mipLevel_, D3D11.MapMode.Read, D3D11.MapFlags.None);

                    sSubData_[texElement_ * texElementDesc_.MipLevels + mipLevel_].DataPointer = subResource_.DataPointer;
                    sSubData_[texElement_ * texElementDesc_.MipLevels + mipLevel_].RowPitch = subResource_.RowPitch;

                    d3dDevice.ImmediateContext.Unmap(sourceTextures[texElement_], mipLevel_);
                }
            }

            var texArray_ =  d3dDevice.CreateTexture2D(texArrayDesc_, sSubData_);

            var viewDesc_ = new D3D11.ShaderResourceViewDescription
            {
                Format = texArrayDesc_.Format,
                ViewDimension = ShaderResourceViewDimension.Texture2DArray,
                Texture2DArray = new Texture2DArrayShaderResourceView()
                { MipLevels = texArrayDesc_.MipLevels, MostDetailedMip = 0, ArraySize = sourceTextures.Count, FirstArraySlice = 0 },
            };

            texArraySRV_ = d3dDevice.CreateShaderResourceView(texArray_, viewDesc_);
            texArraySRV_.DebugName = "Shader Array";

            texArray_.Dispose();
        }
        catch (Exception ex_)
        {
            ErrorHandler.DoErrorHandling(ex_, ErrorHandler.GetCurrentMethod(ex_));
        }

        return texArraySRV_;
    }`

[h1cks]

All this code is what i converted from my Sharpdx project to Vortice.

Sharpdx version is here -> https://insanesoftware.itch.io/pacific-strafe-alpha

[h1cks]

This function I used to use, but i dont know if its 100%, this deals with loading 24 bit and 32 bit.

` public static ID3D11Texture2D GetTexture2DFromBitmap(D3D11.ID3D11Device1 d3dDevice, System.Drawing.Bitmap bitmap, D3D11.Texture2DDescription desc)
{
ID3D11Texture2D tex_ = d3dDevice.CreateTexture2D(desc);

        BitmapData data_ = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);

        int bufferSize_ = data_.Height * data_.Stride;

        //create data buffer 
        byte[] bytes_ = new byte[bufferSize_];
        // copy bitmap data into buffer
        Marshal.Copy(data_.Scan0, bytes_, 0, bytes_.Length);

        bitmap.UnlockBits(data_);

        try
        {
            MappedSubresource resource_ = d3dDevice.ImmediateContext.Map(tex_, 0,
            0,
            D3D11.MapMode.Read,
            Vortice.Direct3D11.MapFlags.None, out int subresource, out int mipSize);

            DataStream stream_ = new DataStream(resource_.DataPointer, bytes_.Length, true, false);

            if (bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
            {
                Debug.Assert((bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb));
                for (int i_ = 0; i_ < bytes_.Length; i_++)
                {
                    stream_.Write(bytes_[i_]);
                    // if i % 3 = 2 then add an alpha channel byte
                    if (i_ % 3 == 2)
                    {
                        stream_.Write((byte)255); //need this to convert to full 32 bit
                    }
                }
            }
            else if (bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format32bppArgb)
            {
                for (int i_ = 0; i_ < bytes_.Length; i_++)
                {
                    stream_.Write(bytes_[i_]);
                    // if i % 3 = 2 then add an alpha channel byte
                    //if (i_ % 3 == 2)
                    //{
                    //    stream_.Write((byte)255); //need this to convert to full 32 bit
                    //}
                }
            }
            else
            {
                Debug.Assert((bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb));
            }

            d3dDevice.ImmediateContext.Unmap(tex_, 0); //to update the data on GPU
            stream_.Dispose();
        }
        catch (Exception ex_)
        {
            ErrorHandler.DoErrorHandling(ex_, ErrorHandler.GetCurrentMethod(ex_));
        }

        return tex_;
    }`

[h1cks]

This function is for the first code, will help

` //====================================================================================================================================//

    public static byte[] GetPixelData(System.Drawing.Bitmap source)
    {
        BitmapData data_ = source.LockBits(new System.Drawing.Rectangle(0, 0, source.Width, source.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, source.PixelFormat);

        int bufferSize_ = data_.Height * data_.Stride;

        //create data buffer 
        byte[] sourceBytes_ = new byte[bufferSize_];
        // copy bitmap data into buffer
        Marshal.Copy(data_.Scan0, sourceBytes_, 0, sourceBytes_.Length);

        source.UnlockBits(data_);

        return sourceBytes_;
    }`

[Gavin-Williams]

Awesome!

[h1cks]

if this thread is satisfied. please mark it answered so other viewers can use it.

[amerkoleci]

Right, thanks for tip @h1cks

[bforl]

Are there still examples using WIC? I couldn't find them in the main project or the samples project. They all seem to use SkiaSharp?

[amerkoleci]

You can find an example here:

https://github.com/amerkoleci/Vortice.Windows.Samples/blob/main/src/Vortice.Framework/Image.cs#L128

Cheers

[bforl]

Thank you, missed that