WIP

Author: DarkFire01

base/applications/CMakeLists.txt

@@ -9,6 +9,9 @@ add_subdirectory(cmdutils)
 add_subdirectory(control)
 add_subdirectory(drwtsn32)
 add_subdirectory(dxdiag)
+add_subdirectory(ddrawtest)
+add_subdirectory(d3d7test)
+add_subdirectory(d3d8test)
 add_subdirectory(extrac32)
 add_subdirectory(findstr)
 add_subdirectory(fltmc)

base/applications/d3d7test/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(d3d7test d3d7test.c)
+set_module_type(d3d7test win32gui UNICODE)
+target_link_libraries(d3d7test dxguid)
+add_importlibs(d3d7test user32 gdi32 ddraw msvcrt kernel32 ntdll)
+add_cd_file(TARGET d3d7test DESTINATION reactos/system32 FOR all)
+

base/applications/d3d7test/d3d7test.c

@@ -0,0 +1,349 @@
+#include <windows.h>
+#include <ddraw.h>
+#include <d3d.h>
+#include <math.h>
+
+typedef struct VTX7
+{
+    float x, y, z;
+    float nx, ny, nz;
+    DWORD diffuse;
+} VTX7;
+
+#define FVF_VTX7 (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE)
+
+static int g_running = 1;
+
+static void MatIdentity(D3DMATRIX *m)
+{
+    ZeroMemory(m, sizeof(*m));
+    m->_11 = 1.0f; m->_22 = 1.0f; m->_33 = 1.0f; m->_44 = 1.0f;
+}
+
+static void MatMul(D3DMATRIX *out, const D3DMATRIX *a, const D3DMATRIX *b)
+{
+    D3DMATRIX r;
+    const float *am = (const float *)&a->_11;
+    const float *bm = (const float *)&b->_11;
+    float *rm = (float *)&r._11;
+    int row, col;
+    for (row = 0; row < 4; row++)
+    {
+        for (col = 0; col < 4; col++)
+        {
+            rm[row * 4 + col] =
+                am[row * 4 + 0] * bm[0 * 4 + col] +
+                am[row * 4 + 1] * bm[1 * 4 + col] +
+                am[row * 4 + 2] * bm[2 * 4 + col] +
+                am[row * 4 + 3] * bm[3 * 4 + col];
+        }
+    }
+    *out = r;
+}
+
+static void MatRotationYawPitch(D3DMATRIX *m, float yaw, float pitch)
+{
+    float cy = (float)cos(yaw), sy = (float)sin(yaw);
+    float cx = (float)cos(pitch), sx = (float)sin(pitch);
+
+    D3DMATRIX ry, rx, r;
+    MatIdentity(&ry);
+    MatIdentity(&rx);
+
+    ry._11 = cy;  ry._13 = sy;
+    ry._31 = -sy; ry._33 = cy;
+
+    rx._22 = cx;  rx._23 = -sx;
+    rx._32 = sx;  rx._33 = cx;
+
+    MatMul(&r, &rx, &ry);
+    *m = r;
+}
+
+static void MatLookAtLH(D3DMATRIX *m,
+                        float ex, float ey, float ez,
+                        float ax, float ay, float az,
+                        float ux, float uy, float uz)
+{
+    float zx = ax - ex, zy = ay - ey, zz = az - ez;
+    float zlen = (float)sqrt(zx*zx + zy*zy + zz*zz);
+    if (zlen > 0.0f) { zx /= zlen; zy /= zlen; zz /= zlen; }
+
+    float xx = uy*zz - uz*zy;
+    float xy = uz*zx - ux*zz;
+    float xz = ux*zy - uy*zx;
+    float xlen = (float)sqrt(xx*xx + xy*xy + xz*xz);
+    if (xlen > 0.0f) { xx /= xlen; xy /= xlen; xz /= xlen; }
+
+    float yx = zy*xz - zz*xy;
+    float yy = zz*xx - zx*xz;
+    float yz = zx*xy - zy*xx;
+
+    MatIdentity(m);
+
+    m->_11 = xx; m->_12 = yx; m->_13 = zx;
+    m->_21 = xy; m->_22 = yy; m->_23 = zy;
+    m->_31 = xz; m->_32 = yz; m->_33 = zz;
+
+    m->_41 = -(xx*ex + xy*ey + xz*ez);
+    m->_42 = -(yx*ex + yy*ey + yz*ez);
+    m->_43 = -(zx*ex + zy*ey + zz*ez);
+}
+
+static void MatPerspectiveFovLH(D3DMATRIX *m, float fovy, float aspect, float zn, float zf)
+{
+    float yScale = 1.0f / (float)tan(fovy * 0.5f);
+    float xScale = yScale / aspect;
+    ZeroMemory(m, sizeof(*m));
+    m->_11 = xScale;
+    m->_22 = yScale;
+    m->_33 = zf / (zf - zn);
+    m->_34 = 1.0f;
+    m->_43 = (-zn * zf) / (zf - zn);
+}
+
+static const VTX7 g_cube[36] =
+{
+    /* +Z (red) */
+    {-1,-1, 1, 0,0,1, 0xFFFF0000}, { 1,-1, 1, 0,0,1, 0xFFFF0000}, { 1, 1, 1, 0,0,1, 0xFFFF0000},
+    {-1,-1, 1, 0,0,1, 0xFFFF0000}, { 1, 1, 1, 0,0,1, 0xFFFF0000}, {-1, 1, 1, 0,0,1, 0xFFFF0000},
+    /* -Z (green) */
+    { 1,-1,-1, 0,0,-1, 0xFF00FF00}, {-1,-1,-1, 0,0,-1, 0xFF00FF00}, {-1, 1,-1, 0,0,-1, 0xFF00FF00},
+    { 1,-1,-1, 0,0,-1, 0xFF00FF00}, {-1, 1,-1, 0,0,-1, 0xFF00FF00}, { 1, 1,-1, 0,0,-1, 0xFF00FF00},
+    /* +X (blue) */
+    { 1,-1, 1, 1,0,0, 0xFF0000FF}, { 1,-1,-1, 1,0,0, 0xFF0000FF}, { 1, 1,-1, 1,0,0, 0xFF0000FF},
+    { 1,-1, 1, 1,0,0, 0xFF0000FF}, { 1, 1,-1, 1,0,0, 0xFF0000FF}, { 1, 1, 1, 1,0,0, 0xFF0000FF},
+    /* -X (yellow) */
+    {-1,-1,-1, -1,0,0, 0xFFFFFF00}, {-1,-1, 1, -1,0,0, 0xFFFFFF00}, {-1, 1, 1, -1,0,0, 0xFFFFFF00},
+    {-1,-1,-1, -1,0,0, 0xFFFFFF00}, {-1, 1, 1, -1,0,0, 0xFFFFFF00}, {-1, 1,-1, -1,0,0, 0xFFFFFF00},
+    /* +Y (cyan) */
+    {-1, 1, 1, 0,1,0, 0xFF00FFFF}, { 1, 1, 1, 0,1,0, 0xFF00FFFF}, { 1, 1,-1, 0,1,0, 0xFF00FFFF},
+    {-1, 1, 1, 0,1,0, 0xFF00FFFF}, { 1, 1,-1, 0,1,0, 0xFF00FFFF}, {-1, 1,-1, 0,1,0, 0xFF00FFFF},
+    /* -Y (magenta) */
+    {-1,-1,-1, 0,-1,0, 0xFFFF00FF}, { 1,-1,-1, 0,-1,0, 0xFFFF00FF}, { 1,-1, 1, 0,-1,0, 0xFFFF00FF},
+    {-1,-1,-1, 0,-1,0, 0xFFFF00FF}, { 1,-1, 1, 0,-1,0, 0xFFFF00FF}, {-1,-1, 1, 0,-1,0, 0xFFFF00FF},
+};
+
+static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    switch (msg)
+    {
+        case WM_CLOSE:
+            DestroyWindow(hwnd);
+            return 0;
+        case WM_DESTROY:
+            g_running = 0;
+            PostQuitMessage(0);
+            return 0;
+        case WM_KEYDOWN:
+            if (wParam == VK_ESCAPE)
+            {
+                DestroyWindow(hwnd);
+                return 0;
+            }
+            return 0;
+        default:
+            return DefWindowProcW(hwnd, msg, wParam, lParam);
+    }
+}
+
+static HRESULT CreateZBuffer(IDirectDraw7 *ddraw, DWORD w, DWORD h, IDirectDrawSurface7 **outZ)
+{
+    DDSURFACEDESC2 desc;
+    ZeroMemory(&desc, sizeof(desc));
+    desc.dwSize = sizeof(desc);
+    desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
+    desc.dwWidth = w;
+    desc.dwHeight = h;
+    desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | DDSCAPS_VIDEOMEMORY;
+    desc.ddpfPixelFormat.dwSize = sizeof(desc.ddpfPixelFormat);
+    desc.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER;
+    desc.ddpfPixelFormat.dwZBufferBitDepth = 16;
+    return IDirectDraw7_CreateSurface(ddraw, &desc, outZ, NULL);
+}
+
+static void ShowHr(HWND hwnd, const wchar_t *what, HRESULT hr)
+{
+    wchar_t buf[256];
+    wsprintfW(buf, L"%s failed (hr=0x%08lx)", what, (DWORD)hr);
+    MessageBoxW(hwnd, buf, L"d3d7test", MB_ICONERROR);
+}
+
+int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
+{
+    WNDCLASSW wc;
+    HWND hwnd;
+    MSG msg;
+    HRESULT hr;
+
+    IDirectDraw7 *ddraw = NULL;
+    IDirectDrawSurface7 *primary = NULL;
+    IDirectDrawSurface7 *back = NULL;
+    IDirectDrawSurface7 *zbuf = NULL;
+    IDirect3D7 *d3d = NULL;
+    IDirect3DDevice7 *dev = NULL;
+    DDSURFACEDESC2 sdesc;
+
+    RECT rc;
+    DWORD W, H;
+    DWORD tickStart;
+
+    (void)hPrevInstance;
+    (void)lpCmdLine;
+
+    ZeroMemory(&wc, sizeof(wc));
+    wc.lpfnWndProc = WndProc;
+    wc.hInstance = hInstance;
+    wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
+    wc.lpszClassName = L"D3D7TestWindow";
+    if (!RegisterClassW(&wc))
+        return 1;
+
+    hwnd = CreateWindowW(wc.lpszClassName, L"D3D7 Cube Test",
+                         WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
+                         NULL, NULL, hInstance, NULL);
+    if (!hwnd)
+        return 1;
+
+    ShowWindow(hwnd, nCmdShow);
+    UpdateWindow(hwnd);
+
+    GetClientRect(hwnd, &rc);
+    W = (DWORD)(rc.right - rc.left);
+    H = (DWORD)(rc.bottom - rc.top);
+    if (!W) W = 640;
+    if (!H) H = 480;
+
+    hr = DirectDrawCreateEx(NULL, (VOID **)&ddraw, &IID_IDirectDraw7, NULL);
+    if (FAILED(hr))
+    {
+        ShowHr(hwnd, L"DirectDrawCreateEx", hr);
+        return 1;
+    }
+
+    hr = IDirectDraw7_SetCooperativeLevel(ddraw, hwnd, DDSCL_NORMAL);
+    if (FAILED(hr))
+    {
+        ShowHr(hwnd, L"SetCooperativeLevel", hr);
+        goto Cleanup;
+    }
+
+    ZeroMemory(&sdesc, sizeof(sdesc));
+    sdesc.dwSize = sizeof(sdesc);
+    sdesc.dwFlags = DDSD_CAPS;
+    sdesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+
+    hr = IDirectDraw7_CreateSurface(ddraw, &sdesc, &primary, NULL);
+    if (FAILED(hr))
+    {
+        ShowHr(hwnd, L"Create primary surface", hr);
+        goto Cleanup;
+    }
+
+    /* Create an offscreen render target in windowed mode */
+    ZeroMemory(&sdesc, sizeof(sdesc));
+    sdesc.dwSize = sizeof(sdesc);
+    sdesc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
+    sdesc.dwWidth = W;
+    sdesc.dwHeight = H;
+    sdesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
+    hr = IDirectDraw7_CreateSurface(ddraw, &sdesc, &back, NULL);
+    if (FAILED(hr))
+    {
+        ShowHr(hwnd, L"Create offscreen render surface", hr);
+        goto Cleanup;
+    }
+
+    hr = IDirectDraw7_QueryInterface(ddraw, &IID_IDirect3D7, (VOID **)&d3d);
+    if (FAILED(hr))
+    {
+        ShowHr(hwnd, L"QueryInterface(IDirect3D7)", hr);
+        goto Cleanup;
+    }
+
+    hr = CreateZBuffer(ddraw, W, H, &zbuf);
+    if (SUCCEEDED(hr))
+        IDirectDrawSurface7_AddAttachedSurface(back, zbuf);
+
+    hr = IDirect3D7_CreateDevice(d3d, &IID_IDirect3DHALDevice, back, &dev);
+    if (FAILED(hr))
+        hr = IDirect3D7_CreateDevice(d3d, &IID_IDirect3DRGBDevice, back, &dev);
+    if (FAILED(hr))
+    {
+        ShowHr(hwnd, L"CreateDevice", hr);
+        goto Cleanup;
+    }
+
+    {
+        D3DVIEWPORT7 vp;
+        vp.dwX = 0;
+        vp.dwY = 0;
+        vp.dwWidth = W;
+        vp.dwHeight = H;
+        vp.dvMinZ = 0.0f;
+        vp.dvMaxZ = 1.0f;
+        IDirect3DDevice7_SetViewport(dev, &vp);
+    }
+
+    IDirect3DDevice7_SetRenderState(dev, D3DRENDERSTATE_ZENABLE, D3DZB_TRUE);
+    IDirect3DDevice7_SetRenderState(dev, D3DRENDERSTATE_LIGHTING, FALSE);
+    IDirect3DDevice7_SetRenderState(dev, D3DRENDERSTATE_CULLMODE, D3DCULL_CCW);
+
+    tickStart = GetTickCount();
+
+    while (g_running)
+    {
+        while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
+        {
+            TranslateMessage(&msg);
+            DispatchMessageW(&msg);
+        }
+
+        {
+            float t = (GetTickCount() - tickStart) * 0.001f;
+            D3DMATRIX world, view, proj;
+            MatRotationYawPitch(&world, t, t * 0.7f);
+            MatLookAtLH(&view, 0.0f, 0.0f, -5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
+            MatPerspectiveFovLH(&proj, 3.1415926f / 4.0f, (float)W / (float)H, 0.1f, 100.0f);
+
+            IDirect3DDevice7_SetTransform(dev, D3DTRANSFORMSTATE_WORLD, &world);
+            IDirect3DDevice7_SetTransform(dev, D3DTRANSFORMSTATE_VIEW, &view);
+            IDirect3DDevice7_SetTransform(dev, D3DTRANSFORMSTATE_PROJECTION, &proj);
+
+            IDirect3DDevice7_Clear(dev, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00202040, 1.0f, 0);
+
+            if (SUCCEEDED(IDirect3DDevice7_BeginScene(dev)))
+            {
+                IDirect3DDevice7_DrawPrimitive(dev, D3DPT_TRIANGLELIST, FVF_VTX7, (LPVOID)g_cube, 36, 0);
+                IDirect3DDevice7_EndScene(dev);
+            }
+        }
+
+        /* Present (blit) the offscreen surface to the primary */
+        ZeroMemory(&rc, sizeof(rc));
+        GetClientRect(hwnd, &rc);
+        hr = IDirectDrawSurface7_Blt(primary, &rc, back, NULL, DDBLT_WAIT, NULL);
+        if (hr == DDERR_SURFACELOST)
+        {
+            IDirectDrawSurface7_Restore(primary);
+            IDirectDrawSurface7_Restore(back);
+            if (zbuf) IDirectDrawSurface7_Restore(zbuf);
+        }
+
+        Sleep(1);
+    }
+
+Cleanup:
+    if (dev) IDirect3DDevice7_Release(dev);
+    if (zbuf) IDirectDrawSurface7_Release(zbuf);
+    if (d3d) IDirect3D7_Release(d3d);
+    if (back) IDirectDrawSurface7_Release(back);
+    if (primary) IDirectDrawSurface7_Release(primary);
+    if (ddraw)
+    {
+        IDirectDraw7_SetCooperativeLevel(ddraw, hwnd, DDSCL_NORMAL);
+        IDirectDraw7_Release(ddraw);
+    }
+    return 0;
+}
+

base/applications/d3d8test/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(d3d8test d3d8test.c)
+set_module_type(d3d8test win32gui UNICODE)
+target_link_libraries(d3d8test dxguid)
+add_importlibs(d3d8test user32 gdi32 d3d8 msvcrt kernel32 ntdll)
+add_cd_file(TARGET d3d8test DESTINATION reactos/system32 FOR all)
+