Файл RenderD3D.cpp

См. исходные тексты.

Функции
HRESULT __stdcall	DDrawDisplayModesEnumerator (DDSURFACEDESC2 *pSurfaceDesc, __int16 *found_compatible_mode)
HRESULT __stdcall	D3DDeviceEnumerator (const GUID *lpGUID, const char *lpDeviceDesc, const char *lpDeviceName, D3DDEVICEDESC *pHWDesc, D3DDEVICEDESC *pSWDesc, RenderD3D_aux *a6)
int __stdcall	RenderD3D__DeviceEnumerator (GUID *lpGUID, const char *lpDevDesc, const char *lpDriverName, RenderD3D__DevInfo *pOut)
HRESULT __stdcall	D3DZBufferFormatEnumerator (DDPIXELFORMAT *Src, DDPIXELFORMAT *Dst)
unsigned int	GetMaxMipLevels (unsigned int uDim)

Функции

DDrawDisplayModesEnumerator()

HRESULT __stdcall DDrawDisplayModesEnumerator	(	DDSURFACEDESC2 *	pSurfaceDesc,
		__int16 *	found_compatible_mode
	)

См. определение в файле RenderD3D.cpp строка 9

                                                                              {
    if (pSurfaceDesc->ddsCaps.dwCaps | DDSCAPS_3DDEVICE) {
        *found_compatible_mode = 1;
        return S_OK;
    }
    return 1;
}

Используется в RenderD3D__DeviceEnumerator().

Граф вызова функции:

D3DDeviceEnumerator()

HRESULT __stdcall D3DDeviceEnumerator	(	const GUID *	lpGUID,
		const char *	lpDeviceDesc,
		const char *	lpDeviceName,
		D3DDEVICEDESC *	pHWDesc,
		D3DDEVICEDESC *	pSWDesc,
		RenderD3D_aux *	a6
	)

См. определение в файле RenderD3D.cpp строка 18

                                                                       {
    int v7 = -1;
    if (pHWDesc->dwFlags) {
        if (!a6->ptr_4->pGUID) v7 = 0;
        if (pHWDesc->dwFlags && a6->ptr_4->pGUID) v7 = 1;
    }
    if (!strcmp(lpDeviceName, "RGB Emulation") && !a6->ptr_4->pGUID) v7 = 2;
    if (!strcmp(lpDeviceName, "Reference Rasterizer") && !a6->ptr_4->pGUID)
        v7 = 3;
    if (v7 != -1) {
        a6->pInfo[v7].bIsDeviceCompatible = 1;
        a6->pInfo[v7].uCaps = 0;
        if (!(pHWDesc->dpcTriCaps.dwSrcBlendCaps & 0x10))
            a6->pInfo[v7].uCaps |= 2;
        if (!(pHWDesc->dpcTriCaps.dwSrcBlendCaps & 2)) a6->pInfo[v7].uCaps |= 4;
        if (!(pHWDesc->dpcTriCaps.dwSrcBlendCaps & 1)) a6->pInfo[v7].uCaps |= 8;
        if (!(pHWDesc->dpcTriCaps.dwDestBlendCaps & 0x20))
            a6->pInfo[v7].uCaps |= 16;
        if (!(pHWDesc->dpcTriCaps.dwDestBlendCaps & 2))
            a6->pInfo[v7].uCaps |= 32;
        if (!(pHWDesc->dpcTriCaps.dwDestBlendCaps & 4))
            a6->pInfo[v7].uCaps |= 64;
        if (!(pHWDesc->dwDevCaps & 0x1000)) a6->pInfo[v7].uCaps |= 0x100;
        if (pHWDesc->dpcTriCaps.dwTextureCaps & 0x20)
            a6->pInfo[v7].uCaps |= 0x80;
 
        a6->pInfo[v7].pName = new char[strlen(lpDeviceName) + 1];
        strcpy(a6->pInfo[v7].pName, lpDeviceName);
 
        a6->pInfo[v7].pDescription = new char[strlen(lpDeviceDesc) + 1];
        strcpy(a6->pInfo[v7].pDescription, lpDeviceDesc);
 
        a6->pInfo[v7].pGUID = new GUID;
        memcpy(a6->pInfo[v7].pGUID, lpGUID, 0x10);
 
        a6->pInfo[v7].pDriverName = strdup(a6->ptr_4->pDriverName);
        a6->pInfo[v7].pDeviceDesc = strdup(a6->ptr_4->pDeviceDesc);
        a6->pInfo[v7].pDDraw4DevDesc = strdup(a6->ptr_4->pDDraw4DevDesc);
 
        if (a6->ptr_4->pGUID) {
            a6->pInfo[v7].pDirectDrawGUID = new GUID;
            memcpy(a6->pInfo[v7].pDirectDrawGUID, a6->ptr_4->pGUID, 0x10);
        } else {
            a6->pInfo[v7].pDirectDrawGUID = 0;
        }
        a6->pInfo[v7].uVideoMem = a6->ptr_4->uVideoMem;
    }
    return 1;
}

Перекрестные ссылки RenderD3D__DevInfo::bIsDeviceCompatible, RenderD3D__DevInfo::pDDraw4DevDesc, RenderD3D_D3DDevDesc::pDDraw4DevDesc, RenderD3D__DevInfo::pDescription, RenderD3D__DevInfo::pDeviceDesc, RenderD3D_D3DDevDesc::pDeviceDesc, RenderD3D__DevInfo::pDirectDrawGUID, RenderD3D__DevInfo::pDriverName, RenderD3D_D3DDevDesc::pDriverName, RenderD3D__DevInfo::pGUID, RenderD3D_D3DDevDesc::pGUID, RenderD3D_aux::pInfo, RenderD3D__DevInfo::pName, RenderD3D_aux::ptr_4, RenderD3D__DevInfo::uCaps, RenderD3D__DevInfo::uVideoMem и RenderD3D_D3DDevDesc::uVideoMem.

Используется в RenderD3D__DeviceEnumerator().

Граф вызова функции:

RenderD3D__DeviceEnumerator()

int __stdcall RenderD3D__DeviceEnumerator	(	GUID *	lpGUID,
		const char *	lpDevDesc,
		const char *	lpDriverName,
		RenderD3D__DevInfo *	pOut
	)

См. определение в файле RenderD3D.cpp строка 70

                                                                    {
    size_t v5;                   // eax@1
    size_t v7;                   // eax@13
    DDDEVICEIDENTIFIER ddDevId;  // [sp+4h] [bp-4F8h]@11
    DDSURFACEDESC2 v10;          // [sp+42Ch] [bp-D0h]@16
    DDSCAPS2 ddsCaps;            // [sp+4A8h] [bp-54h]@14
    unsigned int uFreeVideoMem;  // [sp+4B8h] [bp-44h]@14
    RenderD3D_aux aux;           // [sp+4BCh] [bp-40h]@19
    IDirect3D3 *pDirect3D3;      // [sp+4C4h] [bp-38h]@18
    int is_there_a_compatible_screen_mode;  // [sp+4C8h] [bp-34h]@16
    IDirectDraw4 *pDirectDraw4;             // [sp+4F8h] [bp-4h]@7
 
    RenderD3D_D3DDevDesc v20 = {0};
    size_t v4 = strlen(lpDriverName);
    v20.pDriverName = new char[v4 + 1];
    v5 = strlen(lpDevDesc);
    v20.pDeviceDesc = new char[v5 + 1];
    strcpy(v20.pDriverName, lpDriverName);
    strcpy(v20.pDeviceDesc, lpDevDesc);
    if (lpGUID) {
        v20.pGUID = new GUID;
        memcpy(v20.pGUID, lpGUID, 0x10);
    } else {
        v20.pGUID = 0;
    }
 
    LPDIRECTDRAW pDirectDraw = nullptr;
    if (FAILED(DirectDrawCreate(v20.pGUID, &pDirectDraw, 0))) {
        delete[] v20.pDriverName;
        delete[] v20.pDeviceDesc;
        delete v20.pGUID;
    } else {
        if (FAILED(pDirectDraw->QueryInterface(IID_IDirectDraw4,
                                               (LPVOID *)&pDirectDraw4))) {
            delete[] v20.pDriverName;
            delete[] v20.pDeviceDesc;
            delete v20.pGUID;
            pDirectDraw->Release();
        } else {
            pDirectDraw->Release();
            if (FAILED(pDirectDraw4->GetDeviceIdentifier(&ddDevId, 1))) {
                v20.pDDraw4DevDesc = 0;
            } else {
                v7 = strlen(ddDevId.szDescription);
                v20.pDDraw4DevDesc = new char[v7 + 1];
                strcpy(v20.pDDraw4DevDesc, ddDevId.szDescription);
            }
            memset(&ddsCaps, 0, sizeof(ddsCaps));
            if (FAILED(pDirectDraw4->GetAvailableVidMem(
                    &ddsCaps, (LPDWORD)&v20.uVideoMem,
                    (LPDWORD)&uFreeVideoMem)))
                v20.uVideoMem = 0;
            memset(&v10, 0, sizeof(v10));
            v10.dwSize = 124;
            v10.dwFlags = 6;
            v10.dwHeight = window->GetWidth();
            v10.dwWidth = window->GetHeight();
            v10.ddpfPixelFormat.dwSize = 32;
 
            is_there_a_compatible_screen_mode = false;
            if (FAILED(pDirectDraw4->EnumDisplayModes(
                    0, 0, &is_there_a_compatible_screen_mode,
                    (LPDDENUMMODESCALLBACK2)DDrawDisplayModesEnumerator)) ||
                !is_there_a_compatible_screen_mode ||
                FAILED(pDirectDraw4->QueryInterface(IID_IDirect3D3,
                                                    (LPVOID *)&pDirect3D3))) {
                delete[] v20.pDriverName;
                delete[] v20.pDeviceDesc;
                // free(v20.pDDraw4DevDesc);
                delete[] v20.pDDraw4DevDesc;
                delete v20.pGUID;
                pDirectDraw4->Release();
            } else {
                aux.pInfo = pOut;
                aux.ptr_4 = &v20;
                pDirect3D3->EnumDevices(
                    (LPD3DENUMDEVICESCALLBACK)D3DDeviceEnumerator, &aux);
                delete[] v20.pDriverName;
                delete[] v20.pDeviceDesc;
                delete[] v20.pDDraw4DevDesc;
                delete v20.pGUID;
                pDirectDraw4->Release();
                pDirectDraw4 = 0;
                pDirect3D3->Release();
            }
        }
    }
    return 1;
}

Перекрестные ссылки D3DDeviceEnumerator(), DDrawDisplayModesEnumerator(), RenderD3D_D3DDevDesc::pDDraw4DevDesc, RenderD3D_D3DDevDesc::pDeviceDesc, RenderD3D_D3DDevDesc::pDriverName, RenderD3D_D3DDevDesc::pGUID, RenderD3D_aux::pInfo, RenderD3D_aux::ptr_4 и RenderD3D_D3DDevDesc::uVideoMem.

Используется в RenderD3D::GetAvailableDevices().

Граф вызовов:

Граф вызова функции:

D3DZBufferFormatEnumerator()

HRESULT __stdcall D3DZBufferFormatEnumerator	(	DDPIXELFORMAT *	Src,
		DDPIXELFORMAT *	Dst
	)

См. определение в файле RenderD3D.cpp строка 162

                                                                 {
    if (Src->dwFlags & (0x400 | 0x2000)) {
        if (Src->dwRGBBitCount == 16 && !Src->dwRBitMask) {
            memcpy(Dst, Src, sizeof(DDPIXELFORMAT));
            return 0;
        }
        if (!Dst->dwSize) {
            memcpy(Dst, Src, sizeof(DDPIXELFORMAT));
            return 1;
        }
    }
    return 1;
}

Используется в RenderD3D::CreateDevice().

Граф вызова функции:

GetMaxMipLevels()

unsigned int GetMaxMipLevels

(

unsigned int

uDim

)

См. определение в файле RenderD3D.cpp строка 771

                                                {
    int v2 = 0;
    unsigned int v3 = uDim - 1;
    while (v3 & 1) {
        v3 >>= 1;
        ++v2;
    }
    return v3 == 0 ? v2 : 0;
}

Используется в RenderD3D::CreateTexture().

Граф вызова функции: