kalite yükseltme.görsel ve donanım olarak fark yok.

cpu gpu ramda fark olmuyor
oyundada görsel olarak fark olmuyor.

upscale yapmak daha mantıklı

grpimagetexture.cpp

Kod:

#include "StdAfx.h"
#include "../eterBase/MappedFile.h"
#include "../eterPack/EterPackManager.h"
#include "GrpImageTexture.h"

bool CGraphicImageTexture::Lock(int* pRetPitch, void** ppRetPixels, int level)
{
    D3DLOCKED_RECT lockedRect;
    if (FAILED(m_lpd3dTexture->LockRect(level, &lockedRect, nullptr, 0)))
        return false;

    *pRetPitch = lockedRect.Pitch;
    *ppRetPixels = static_cast<void*>(lockedRect.pBits);
    return true;
}

void CGraphicImageTexture::Unlock(int level)
{
    if (m_lpd3dTexture) [[likely]]
        m_lpd3dTexture->UnlockRect(level);
}

void CGraphicImageTexture::Initialize()
{
    CGraphicTexture::Initialize();
    m_stFileName = "";
    m_d3dFmt = D3DFMT_UNKNOWN;
    m_dwFilter = 0;
}

void CGraphicImageTexture::Destroy()
{
    CGraphicTexture::Destroy();
    Initialize();
}

bool CGraphicImageTexture::CreateDeviceObjects()
{
    assert(ms_lpd3dDevice != nullptr);
    assert(m_lpd3dTexture == nullptr);

    if (m_stFileName.empty())
    {
        if (FAILED(ms_lpd3dDevice->CreateTexture(m_width, m_height, 1, 0, m_d3dFmt, D3DPOOL_MANAGED, &m_lpd3dTexture)))
            return false;
    }
    else
    {
        CMappedFile mappedFile;
        LPCVOID c_pvMap;

        if (!CEterPackManager::Instance().Get(mappedFile, m_stFileName.c_str(), &c_pvMap))
            return false;

        if (!CreateFromMemoryFile(mappedFile.Size(), c_pvMap, m_d3dFmt, m_dwFilter))
        {
            TraceError("CGraphicImageTexture::CreateDeviceObjects: texture not found(%s)", m_stFileName.c_str());
            return false;
        }
        return true;
    }

    m_bEmpty = false;
    return true;
}

bool CGraphicImageTexture::Create(UINT width, UINT height, D3DFORMAT d3dFmt, DWORD dwFilter)
{
    assert(ms_lpd3dDevice != nullptr);
    Destroy();

    m_width = width;
    m_height = height;
    m_d3dFmt = d3dFmt;
    m_dwFilter = dwFilter;

    return CreateDeviceObjects();
}

void CGraphicImageTexture::CreateFromTexturePointer(const CGraphicTexture* c_pSrcTexture)
{
    if (m_lpd3dTexture)
        m_lpd3dTexture->Release();

    m_width = c_pSrcTexture->GetWidth();
    m_height = c_pSrcTexture->GetHeight();
    m_lpd3dTexture = c_pSrcTexture->GetD3DTexture();

    if (m_lpd3dTexture)
        m_lpd3dTexture->AddRef();

    m_bEmpty = false;
}

bool CGraphicImageTexture::CreateDDSTexture(CDXTCImage& image, const BYTE* /*c_pbBuf*/)
{
    int mipmapCount = image.m_dwMipMapCount == 0 ? 1 : image.m_dwMipMapCount;

    D3DFORMAT format;
    if (image.m_CompFormat == PF_DXT5) format = D3DFMT_DXT5;
    else if (image.m_CompFormat == PF_DXT3) format = D3DFMT_DXT3;
    else format = D3DFMT_DXT1;

    // MAKSİMUM KALİTE: Texture Bias ve Düşük Bellek kontrolleri tamamen kaldırıldı.
    LPDIRECT3DTEXTURE8 lpd3dTexture;
    if (FAILED(D3DXCreateTexture(ms_lpd3dDevice, image.m_nWidth, image.m_nHeight,
                                    mipmapCount, 0, format, D3DPOOL_MANAGED, &lpd3dTexture)))
    {
        TraceError("CreateDDSTexture: Cannot create texture");
        return false;
    }

    for (DWORD i = 0; i < static_cast<DWORD>(mipmapCount); ++i)
    {
        D3DLOCKED_RECT lockedRect;
        if (SUCCEEDED(lpd3dTexture->LockRect(i, &lockedRect, nullptr, 0)))
        {
            image.Copy(i, reinterpret_cast<BYTE*>(lockedRect.pBits), lockedRect.Pitch);
            lpd3dTexture->UnlockRect(i);
        }
    }

    m_lpd3dTexture = lpd3dTexture;
    m_width = image.m_nWidth;
    m_height = image.m_nHeight;
    m_bEmpty = false;

    return true;
}

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

    static CDXTCImage image;

    if (image.LoadHeaderFromMemory(static_cast<const BYTE*>(c_pvBuf)))
    {
        return CreateDDSTexture(image, static_cast<const BYTE*>(c_pvBuf));
    }
    else
    {
        D3DXIMAGE_INFO imageInfo;
        // MAKSİMUM KALİTE: En iyi filtreleme ve tam boyut yükleme
        if (FAILED(D3DXCreateTextureFromFileInMemoryEx(
                    ms_lpd3dDevice,
                    c_pvBuf,
                    bufSize,
                    D3DX_DEFAULT, // Orijinal Genişlik
                    D3DX_DEFAULT, // Orijinal Yükseklik
                    D3DX_DEFAULT, // Tüm MipMap'ler
                    0,
                    d3dFmt,
                    D3DPOOL_MANAGED,
                    D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER, // En iyi resample filtresi
                    D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER,
                    0, // ColorKey devre dışı (veya 0xffff00ff)
                    &imageInfo,
                    nullptr,
                    &m_lpd3dTexture)))
        {
            TraceError("CreateFromMemoryFile: Cannot create texture from memory");
            return false;
        }

        m_width = imageInfo.Width;
         m_height = imageInfo.Height;
     
        // MAKSİMUM KALİTE: format düşürme (A8R8G8B8 -> A4R4G4B4) mantığı tamamen kaldırıldı.
        // Artık her zaman orijinal formatında kalır.
    }

    m_bEmpty = false;
    return true;
}

void CGraphicImageTexture::SetFileName(const char* c_szFileName)
{
    m_stFileName = c_szFileName;
}

bool CGraphicImageTexture::CreateFromDiskFile(const char* c_szFileName, D3DFORMAT d3dFmt, DWORD dwFilter)
{
    Destroy();
    SetFileName(c_szFileName);
    m_d3dFmt = d3dFmt;
    m_dwFilter = dwFilter;
    return CreateDeviceObjects();
}

CGraphicImageTexture::CGraphicImageTexture()
{
    Initialize();
}

CGraphicImageTexture::~CGraphicImageTexture()
{
    Destroy();
}

Yükleme sürelerinde fark oluyor mu? Denediniz mi?