[Refactor] .DDS Dosyalarını DirectXTex ile Yükleyin ve Yönetin

#include "../eterImageLib/DXTCImage.h"

bool        CreateDDSTexture(CDXTCImage & image, const BYTE * c_pbBuf);

bool CGraphicImageTexture::CreateDDSTexture (CDXTCImage& image, const BYTE* /*c_pbBuf*/)
{
    [...]
}

#include <DirectXTex.h>
D3DFORMAT DXGI_to_D3D9_Format(DXGI_FORMAT format) // Kaiser: DX11 formats to D3D9
{
    switch (format)
    {
    // Compressed Formats (DXT)
    case DXGI_FORMAT_BC1_UNORM:
    case DXGI_FORMAT_BC1_UNORM_SRGB:
        return D3DFMT_DXT1;
    case DXGI_FORMAT_BC2_UNORM:
    case DXGI_FORMAT_BC2_UNORM_SRGB:
        return D3DFMT_DXT3;
    case DXGI_FORMAT_BC3_UNORM:
    case DXGI_FORMAT_BC3_UNORM_SRGB:
        return D3DFMT_DXT5;

    // Standart Color Formats
    case DXGI_FORMAT_B8G8R8A8_UNORM:
    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
        return D3DFMT_A8R8G8B8;
    case DXGI_FORMAT_B8G8R8X8_UNORM:
    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
        return D3DFMT_X8R8G8B8;
    case DXGI_FORMAT_R8G8B8A8_UNORM:
        return D3DFMT_A8B8G8R8;

        // Legacy Formats (Effects etc.)
    case DXGI_FORMAT_B5G6R5_UNORM:
        return D3DFMT_R5G6B5;
    case DXGI_FORMAT_B5G5R5A1_UNORM:
        return D3DFMT_A1R5G5B5;
    case DXGI_FORMAT_B4G4R4A4_UNORM:
        return D3DFMT_A4R4G4B4;
    case DXGI_FORMAT_A8_UNORM:
        return D3DFMT_A8;
    case DXGI_FORMAT_R8_UNORM:
        return D3DFMT_L8; // Luminance
    case DXGI_FORMAT_R8G8_UNORM:
        return D3DFMT_A8L8; // Or V8U8

    default:
        return D3DFMT_UNKNOWN;
    }
}

bool CGraphicImageTexture::CreateFromMemoryFile(UINT bufSize, const void* c_pvBuf, D3DFORMAT d3dFmt, DWORD dwFilter)
{
    assert(ms_lpd3dDevice != NULL);
    assert(m_lpd3dTexture == NULL);

    const uint8_t* ddsData = (const uint8_t*)c_pvBuf;
    size_t ddsSize = (size_t)bufSize;

    DirectX::TexMetadata metadata;
    DirectX::ScratchImage scratchImage;

    HRESULT hr = DirectX::GetMetadataFromDDSMemory(ddsData, ddsSize, DirectX::DDS_FLAGS_NONE, metadata);

    if (SUCCEEDED(hr))
    {
        hr = DirectX::LoadFromDDSMemory(ddsData, ddsSize, DirectX::DDS_FLAGS_NONE, &metadata, scratchImage);
        if (FAILED(hr))
        {
            TraceError("CreateFromMemoryFile: DirectXTex LoadFromDDSMemory failed");
            return false;
        }


        // Convert to D3D9
        D3DFORMAT targetFmt = DXGI_to_D3D9_Format(metadata.format);
        if (targetFmt == D3DFMT_UNKNOWN)
        {
            // Unknown format
            TraceError("CreateFromMemoryFile: Unsupported DDS format conversion");
            
            /* or
            Kaiser: Experimental!
            If a specific format is required, force that format:
            targetFmt = (d3dFmt != D3DFMT_UNKNOWN) ? d3dFmt : D3DFMT_A8R8G8B8;
            */
        }

        int mipmapCount = (int)metadata.mipLevels;
        D3DPOOL pool = D3DPOOL_MANAGED;
        DWORD usage = 0;

        if (FAILED(ms_lpd3dDevice->CreateTexture(
            (UINT)metadata.width,
            (UINT)metadata.height,
            mipmapCount,
            usage,
            targetFmt,
            pool,
            &m_lpd3dTexture,
            NULL)))
        {
            TraceError("CreateFromMemoryFile: Cannot create D3D9 texture via DirectXTex info");
            return false;
        }

        // Copy data (including mipmaps)
        for (size_t i = 0; i < metadata.mipLevels; ++i)
        {
            const DirectX::Image* img = scratchImage.GetImage(i, 0, 0);
            if (!img) continue;

            D3DLOCKED_RECT lockedRect;
            if (FAILED(m_lpd3dTexture->LockRect((UINT)i, &lockedRect, NULL, 0)))
            {
                TraceError("CreateFromMemoryFile: Cannot lock texture for copying");
                continue;
            }

            // For DXT formats (Block Compression)
            if (DirectX::IsCompressed(metadata.format))
            {
                size_t numBytes = img->slicePitch;
                if (numBytes > 0)
                {
                    memcpy(lockedRect.pBits, img->pixels, numBytes);
                }
            }
            else
            {
                // (ARGB etc.)
                BYTE* pDest = (BYTE*)lockedRect.pBits;
                const BYTE* pSrc = img->pixels;
                size_t rowPitch = img->rowPitch;
                size_t height = img->height;
                size_t copySize = (rowPitch < (size_t)lockedRect.Pitch) ? rowPitch : (size_t)lockedRect.Pitch;

                for (size_t y = 0; y < height; ++y)
                {
                    memcpy(pDest, pSrc, copySize);
                    pDest += lockedRect.Pitch;
                    pSrc += rowPitch;
                }
            }

            m_lpd3dTexture->UnlockRect((UINT)i);
        }

        m_width = (UINT)metadata.width;
        m_height = (UINT)metadata.height;
    }
    else
    {
        // Kaiser: Old Method >>>>>>
        D3DXIMAGE_INFO imageInfo;
        if (FAILED(D3DXCreateTextureFromFileInMemoryEx(
            ms_lpd3dDevice,
            c_pvBuf,
            bufSize,
            D3DX_DEFAULT,
            D3DX_DEFAULT,
            D3DX_DEFAULT,
            0,
            d3dFmt,
            D3DPOOL_MANAGED,
            dwFilter,
            dwFilter,
            0xffff00ff,
            &imageInfo,
            NULL,
            &m_lpd3dTexture)))
        {
            TraceError("CreateFromMemoryFile: Cannot create texture (D3DX Fallback failed)");
            return false;
        }

        m_width = imageInfo.Width;
        m_height = imageInfo.Height;
    }

    m_bEmpty = false;
    return true;
}

#pragma comment( lib, "python27.lib" )
..
..
#ifdef _DEBUG // Ekle
#pragma comment( lib, "DirectXTex_debug.lib" )
#else
#pragma comment( lib, "DirectXTex_release.lib" )
#endif