How do I fix dll exception in win32 app?

JWG 146

I get an exception on

    d3d11DC->IASetPrimitiveTopology(
        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

Exception thrown at 0x00007FFFD5E2D909 (d3d11.dll) in Win32OpenGL.exe: 0xC0000005: Access violation writing location 0x00007FFF3AEDD6B4.

Call Stack :

d3d11.dll!00007fffd5e2d909() Unknown Win32OpenGL2OpenGL.exe!d3dDrawShape() Line 1138 C++ Win32OpenGL.exe!wWinMain(HINSTANCE__ * hInstance, HINSTANCE__ * hPrevInstance, wchar_t * lpCmdLine, int nCmdShow) Line 2782 C++ [External Code]

How can I fix this error?

Xiaopo Yang - MSFT 12,726 Reputation points Microsoft Vendor

2023-03-22T01:26:21.9+00:00

Could you please show a minimal, reproducible sample without private information? You can also refer to DXGIDesktopDuplication sample which involves ID3D11DeviceContext::IASetPrimitiveTopology in.

JWG 146

The fault was evidently my own. I called the function before creating the D3D11 Device and Context.

However, I get an error on the next line.

GetClientRect(hWnd, &winRect);

Can't figure out why, since the handle is legit.

Exception thrown at 0x00007FFFD5E1360F (d3d11.dll) in Win32OpenGL.exe: 0xC0000005: Access violation reading location 0x00000000000000C5

Call Stack :

d3d11.dll!00007fffd5e1360f() Unknown d3d11.dll!00007fffd5e015c9() Unknown Win32OpenGL.exe!d3dDrawShape() Line 1128 C++ Win32OpenGL.exe!wWinMain(HINSTANCE__ * hInstance, HINSTANCE__ * hPrevInstance, wchar_t * lpCmdLine, int nCmdShow) Line 2831 C++ [External Code]

Here is a minimum code.

If any errors, there may be missing header files from generated code. Or I missed a variable. Please let me know.

#include <WindowsX.h>
#include <Winuser.h>
#pragma comment(lib, "User32.lib")
#include <vector>
//#include <tchar.h>
//#include <winerror.h>
#include <directxmath.h>
#include <sys/stat.h>
#include <iostream>
#include <fstream>
#include <string>

#include <direct.h>
#include "Shlwapi.h"
#include <shobjidl_core.h>

#include <Uxtheme.h>
#include <dwmapi.h>
#include <assert.h>
#include <d3d11.h>
#pragma comment(lib, "d3d11.lib")

#include <dxgi.h>
#pragma comment(lib, "DXGI.lib")

#include <d3dcompiler.h>
#pragma comment(lib, "D3DCompiler.lib")

#include "resource.h"

using namespace std;
/* DirectXMath uses the C++ namespace DirectX */
using namespace DirectX;

/* permanent rendering context */
HGLRC	hRC = nullptr;
/* private GDI device context */
HDC	hDC = nullptr, winHDC = nullptr;
/* window handle */
HWND hWnd = nullptr;
/* current instance */
HINSTANCE hInst, HInstance, curHI, prevHI;
/* title bar text */
WCHAR	szTitle[MAX_LOADSTRING];
/* main window class name */
WCHAR	szWindowClass[MAX_LOADSTRING];
/* Rectangle Upper Left & Lower Right Values */
RECT WindowRect, DesktopRect, BitmapRect;

HRESULT hr = S_OK;

/* monitor [multiple] key presses */
bool keys[256],
/* Window Active Flag - whether or not Window minimized */
		active = TRUE;

const int winW = 640, winH = 480, bits = 16;
const char* title; // window title
bool fail, canExit, test, draw, canClose, drawing;

PAINTSTRUCT ps;
HDC hdc;

ID3D11Device* d3d11D;
ID3D11DeviceContext* d3d11DC;
IDXGISwapChain* d3d11SC;
ID3D11RenderTargetView* d3d11FBV;

ID3DBlob* vsBlob, * psBlob, * shaderCompileErrorsBlob;
static bool d3dWinResized = false;
bool d3dSwitched = false, d3dDrawReady = false, d3dRend = false;

ID3D11VertexShader* vertexShader = nullptr;
ID3D11PixelShader* pixelShader = nullptr;
ID3D11InputLayout* inputLayout = nullptr;
ID3D11Buffer* vertexBuffer = nullptr, * g_pVertexBuffer;

UINT numVerts, stride, offset;





static void exitStatus(const bool& fail) {
    /* 	The program failed (1)*/
    if (fail) {
        exit(EXIT_FAILURE);
    }
    /*	The program was successful (0)*/
    else { exit(EXIT_SUCCESS); }
}

static void d3dDrawShape() {
    FLOAT backgroundColor[4] = { 0.1f, 0.2f, 0.6f, 1.0f };
    d3d11DC->ClearRenderTargetView(d3d11FBV, backgroundColor);

    RECT winRect;
    GetClientRect(hWnd, &winRect);
    D3D11_VIEWPORT viewport = { 
        0.0f, 0.0f, 
        (FLOAT)(winRect.right - winRect.left), 
        (FLOAT)(winRect.bottom - winRect.top), 0.0f, 1.0f 
    };
    d3d11DC->RSSetViewports(1, &viewport);

    d3d11DC->OMSetRenderTargets(1, &d3d11FBV, nullptr);

    d3d11DC->IASetPrimitiveTopology(
        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    d3d11DC->IASetInputLayout(inputLayout);

    d3d11DC->VSSetShader(vertexShader, nullptr, 0);
    d3d11DC->PSSetShader(pixelShader, nullptr, 0);

    d3d11DC->IASetVertexBuffers(
        0, 1, &vertexBuffer, &stride, &offset);

    d3d11DC->Draw(numVerts, 0);

    d3d11SC->Present(1, 0);
}

static void createVertexBuffer() {
    // Create Vertex Buffer
    vertexBuffer;
    numVerts;
    stride;
    offset;
    {
        float vertexData[] = { // x, y, r, g, b, a
            0.0f,  0.5f, 0.f, 1.f, 0.f, 1.f,
            0.5f, -0.5f, 1.f, 0.f, 0.f, 1.f,
            -0.5f, -0.5f, 0.f, 0.f, 1.f, 1.f
        };
        stride = 6 * sizeof(float);
        numVerts = sizeof(vertexData) / stride;
        offset = 0;

        D3D11_BUFFER_DESC vertexBufferDesc = {};
        vertexBufferDesc.ByteWidth = sizeof(vertexData);
        vertexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
        vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

        D3D11_SUBRESOURCE_DATA vertexSubresourceData = {
            vertexData
        };

        HRESULT hResult = d3d11D->CreateBuffer(
            &vertexBufferDesc,
            &vertexSubresourceData,
            &vertexBuffer);
        //assert(SUCCEEDED(hResult));
        if (SUCCEEDED(hResult)) {

            d3dRend = true;
        }
    }
}

static void createInputLayer() {
    // Create Input Layout
    ID3D11InputLayout* inputLayout;
    {
        D3D11_INPUT_ELEMENT_DESC inputElementDesc[] =
        {
            {
                "POS", 0, DXGI_FORMAT_R32G32_FLOAT,
                0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0
            },
            {
                "COL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT,
                0, D3D11_APPEND_ALIGNED_ELEMENT,
                D3D11_INPUT_PER_VERTEX_DATA, 0
            }
        };

        HRESULT hResult =
            d3d11D->CreateInputLayout(
                inputElementDesc,
                ARRAYSIZE(inputElementDesc),
                vsBlob->GetBufferPointer(),
                vsBlob->GetBufferSize(),
                &inputLayout);
        //assert(SUCCEEDED(hResult));
        if (SUCCEEDED(hResult)) {
            createVertexBuffer();
        }
        vsBlob->Release();
    }
}

static void createPixelShader() {
    // Create Pixel Shader
    pixelShader;
    {
        //ID3DBlob* psBlob;
        //ID3DBlob* shaderCompileErrorsBlob;
        HRESULT hResult = D3DCompileFromFile(
            L"shaders.hlsl", nullptr, nullptr,
            "ps_main", "ps_4_0", 0, 0, &psBlob,
            &shaderCompileErrorsBlob);
        if (FAILED(hResult))
        {
            const char* errorString = NULL;
            if (hResult ==
                HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
                errorString =
                "Could not compile shader; file not found";
            else if (shaderCompileErrorsBlob) {
                errorString =
                    (const char*)shaderCompileErrorsBlob->GetBufferPointer();
                shaderCompileErrorsBlob->Release();
            }
            MessageBoxA(
                0, errorString,
                "Shader Compiler Error",
                MB_ICONERROR | MB_OK);
            fail = false;
            exitStatus(fail);
            //return 1;
        }

        hResult = d3d11D->CreatePixelShader(
            psBlob->GetBufferPointer(),
            psBlob->GetBufferSize(),
            nullptr, &pixelShader);
        //assert(SUCCEEDED(hResult));
        if (SUCCEEDED(hResult)) {
            createInputLayer();
        }
        psBlob->Release();
    }
}

static void createVertexShader() {
    // Create Vertex Shader
    //ID3DBlob* vsBlob;
    vertexShader;
    {
        ID3DBlob* shaderCompileErrorsBlob;
        HRESULT hResult = D3DCompileFromFile(
            L"shaders.hlsl", nullptr, nullptr, 
            "vs_main", "vs_4_0", 0, 0, &vsBlob, 
            &shaderCompileErrorsBlob);
        if (FAILED(hResult))
        {
            const char* errorString = NULL;
            if (hResult == 
                HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
                errorString = 
                "Could not compile shader; file not found";
            else if (shaderCompileErrorsBlob) {
                errorString = 
                    (const char*)shaderCompileErrorsBlob->GetBufferPointer();
                shaderCompileErrorsBlob->Release();
            }
            MessageBoxA(
                0, errorString, 
                "Shader Compiler Error", 
                MB_ICONERROR | MB_OK);
            fail = false;
            exitStatus(fail);
            //return 1;
        }

        hResult = d3d11D->CreateVertexShader(
            vsBlob->GetBufferPointer(), 
            vsBlob->GetBufferSize(), 
            nullptr, &vertexShader);
        //assert(SUCCEEDED(hResult));
        if (SUCCEEDED(hResult)) {
            createPixelShader();
        }
    }
}

static void UsingD3D() {
    // Create D3D11 Device and Context
    ID3D11Device* d3d11Device;
    ID3D11DeviceContext* d3d11DeviceContext; {
        ID3D11Device* baseDevice;
        ID3D11DeviceContext* baseDeviceContext;
        D3D_FEATURE_LEVEL featureLevels[] = { 
            D3D_FEATURE_LEVEL_10_0 
        };
        UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#if defined(DEBUG_BUILD)
        creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

        HRESULT hResult = D3D11CreateDevice(
            0, D3D_DRIVER_TYPE_HARDWARE,
            0, creationFlags,
            featureLevels, ARRAYSIZE(featureLevels),
            D3D11_SDK_VERSION, &baseDevice,
            0, &baseDeviceContext);

        if (FAILED(hResult)) {
            MessageBoxA(
                0, "D3D11CreateDevice() failed", 
                "Fatal Error", MB_OK);


            fail = true;
            return exitStatus(fail);
        }

        // Get interface of D3D11 Device and Context
        hResult = baseDevice->QueryInterface(
            __uuidof(ID3D11Device), (void**)&d3d11Device);
        assert(SUCCEEDED(hResult));
        baseDevice->Release();

        hResult = baseDeviceContext->QueryInterface(
            __uuidof(ID3D11DeviceContext), 
            (void**)&d3d11DeviceContext);
        assert(SUCCEEDED(hResult));
        baseDeviceContext->Release();
    }

#ifdef DEBUG_BUILD
    // Set up debug layer to break on D3D11 errors
    ID3D11Debug* d3dDebug = nullptr;
    d3d11Device->QueryInterface(
        __uuidof(ID3D11Debug), (void**)&d3dDebug);
    if (d3dDebug)
    {
        ID3D11InfoQueue* d3dInfoQueue = nullptr;
        if (SUCCEEDED(d3dDebug->QueryInterface(
            __uuidof(ID3D11InfoQueue), (void**)&d3dInfoQueue)))
        {
            d3dInfoQueue->SetBreakOnSeverity(
                D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
            d3dInfoQueue->SetBreakOnSeverity(
                D3D11_MESSAGE_SEVERITY_ERROR, true);
            d3dInfoQueue->Release();
        }
        d3dDebug->Release();
    }
#endif

    // Create Swap Chain
    IDXGISwapChain* d3d11SwapChain;
    {
        /* Create a factory by calling CreateDXGIFactory.
        Because you can create a Direct3D device without creating 
        a swap chain, you might need to retrieve the factory that 
        is used to create the device in order to create a swap 
        chain. You can request the IDXGIDevice interface from the 
        Direct3D device and then use the IDXGIObject::GetParent 
        method to locate the factory. */
        IDXGIDevice* pDXGIDevice = nullptr;
        hr = d3d11Device->QueryInterface(
            __uuidof(IDXGIDevice), (void**)&pDXGIDevice);

        IDXGIAdapter* pDXGIAdapter = nullptr;
        hr = pDXGIDevice->GetAdapter(&pDXGIAdapter);

        IDXGIFactory* pIDXGIFactory = nullptr;
        pDXGIAdapter->GetParent(
            __uuidof(IDXGIFactory), (void**)&pIDXGIFactory);

#ifdef GET_DXGI_FACTORY

        // Get DXGI Factory (needed to create Swap Chain)
        IDXGIFactory* dxgiFactory;
        {
            IDXGIDevice1* dxgiDevice;
            HRESULT hResult = d3d11Device->QueryInterface(
                __uuidof(IDXGIDevice1), (void**)&dxgiDevice);
            assert(SUCCEEDED(hResult));

            UINT i = 0;
            IDXGIAdapter* dxgiAdapter;

            std::vector <IDXGIAdapter*> vAdapters;
            while (dxgiFactory->EnumAdapters(
                i, &dxgiAdapter) != DXGI_ERROR_NOT_FOUND)
            {
                vAdapters.push_back(dxgiAdapter);
                ++i;
            }

            hResult = dxgiDevice->GetAdapter(&dxgiAdapter);
            assert(SUCCEEDED(hResult));
            dxgiDevice->Release();

            DXGI_ADAPTER_DESC adapterDesc;
            dxgiAdapter->GetDesc(&adapterDesc);

            OutputDebugStringA("Graphics Device: ");
            OutputDebugStringW(adapterDesc.Description);

            hResult = dxgiAdapter->GetParent(
                __uuidof(IDXGIFactory), (void**)&dxgiFactory);
            assert(SUCCEEDED(hResult));
            dxgiAdapter->Release();
        }

#endif // GET_DXGI_FACTORY

        /* create a reference device that implements a highly 
        accurate, software implementation of the runtime. 
        To create a reference device, simply specify that the 
        device being created will use a reference driver. */
        
        /* create reference device and swap chain at the same time
        To create a reference device
            1. Define initial parameters for a swap chain. */
        DXGI_SWAP_CHAIN_DESC sd;
        std::ZeroMemory(&sd, sizeof(sd));
        sd.BufferCount = 1;
        sd.BufferDesc.Width = winW;
        sd.BufferDesc.Height = winH;
        sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
        sd.BufferDesc.RefreshRate.Numerator = 60;
        sd.BufferDesc.RefreshRate.Denominator = 1;
        sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
        sd.OutputWindow = hWnd;
        sd.SampleDesc.Count = 1;
        sd.SampleDesc.Quality = 0;
        sd.Windowed = TRUE;

        /* 2. Request a feature level that implements the features 
        your application will need. A reference device can be 
        successfully created for the Direct3D 11 runtime. 
        I use 10 because it supports shader version 4.0 */
        D3D_FEATURE_LEVEL FeatureLevels = D3D_FEATURE_LEVEL_10_0;

        /* 3. Create the device - D3D11CreateDeviceAndSwapChain */
        //HRESULT hr = S_OK;
        D3D_FEATURE_LEVEL FeatureLevel;
        if (FAILED(hr = D3D11CreateDeviceAndSwapChain(
            /* A pointer to the video adapter to use when 
            creating a device. Pass NULL to use the default 
            adapter, which is the first adapter enumerated by 
            IDXGIFactory::EnumAdapters */
            NULL,
            /* represents the driver type to create */
            D3D_DRIVER_TYPE_REFERENCE,
            /* A handle to a DLL that implements a software 
            rasterizer. The value should be non-NULL when 
            D3D_DRIVER_TYPE is D3D_DRIVER_TYPE_SOFTWARE and NULL 
            otherwise */
            NULL,
            /* The runtime layers to enable; values can be bitwise 
            OR'd together */
            0,
            /* A pointer to an array of D3D_FEATURE_LEVELs, which 
            determine the order of feature levels to attempt to 
            create. */
            &FeatureLevels,
            /* The number of elements in pFeatureLevels */
            1,
            /* The SDK version; use D3D11_SDK_VERSION */
            D3D11_SDK_VERSION,
            /* A pointer to a swap chain description containing 
            initialization parameters for the swap chain */
            &sd,
            /* Swap Chain 
            Returns the address of a pointer to the IDXGISwapChain 
            object that represents the swap chain used for 
            rendering */
            &d3d11SwapChain,
            /* Device 
            Returns the address of a pointer to an ID3D11Device 
            object that represents the device created. */
            &d3d11Device,
            /* Feature Level 
            Returns a pointer to a D3D_FEATURE_LEVEL, which 
            represents the first element in an array of feature 
            levels supported by the device. */
            &FeatureLevel,
            /* Device Context 
            Returns the address of a pointer to an 
            ID3D11DeviceContext object that represents the device 
            context.  */
            &d3d11DeviceContext)))
        {
            fail = true;
            exitStatus(fail);
            //return hr;
        }

        HRESULT hResult =
            pIDXGIFactory->CreateSwapChain(
                d3d11Device, &sd, &d3d11SwapChain);
        assert(SUCCEEDED(hResult));

        pIDXGIFactory->Release();
    }

    // Create Framebuffer Render Target
    ID3D11RenderTargetView* d3d11FrameBufferView;
    {
        ID3D11Texture2D* d3d11FrameBuffer;
        HRESULT hResult = d3d11SwapChain->GetBuffer(
            0, __uuidof(ID3D11Texture2D), 
            (void**)&d3d11FrameBuffer);
        assert(SUCCEEDED(hResult));

        hResult = d3d11Device->CreateRenderTargetView(
            d3d11FrameBuffer, 0, &d3d11FrameBufferView);
        assert(SUCCEEDED(hResult));
        d3d11FrameBuffer->Release();
    }

    d3d11D = d3d11Device;
    d3d11DC = d3d11DeviceContext;
    d3d11SC = d3d11SwapChain;
    d3d11FBV = d3d11FrameBufferView;

    FLOAT backgroundColor[4] = { 0.1f, 0.2f, 0.6f, 1.0f };
    d3d11DC->ClearRenderTargetView(d3d11FBV, backgroundColor);

    d3d11SC->Present(1, 0);

    d3d11FrameBufferView->Release();
    d3d11DeviceContext->Release();
    d3d11SwapChain->Release();
    d3d11Device->Release();
}





BOOL CreateWindow(
    char* title, const int& width, 
    const int& height, const int& bits) {
    const wchar_t CLASS_NAME[] = L"OpenGL Window Class";

    ///* Rectangle Upper Left & Lower Right Values */
    //RECT WindowRect;
    /* Set Left Value To 0 */
    WindowRect.left = (long)0;
    /* Set Right Value To Requested Width */
    WindowRect.right = (long)width;
    /* Set Top Value To 0 */
    WindowRect.top = (long)0;
    /* Set Bottom Value To Requested Height */
    WindowRect.bottom = (long)height;

    GetWindowRect(GetDesktopWindow(), &DesktopRect);

    DWORD dwExStyle; // Window Extended Style
    DWORD dwStyle; // Window Style

    /* Holds resulting pixel format Windows finds */
    GLuint PixelFormat;
    /* Windows Class Structure - *** STEP 1 *** */
    WNDCLASSEXW wc;
    #pragma region Window Class Setup

    wc.cbSize = sizeof(WNDCLASSEX);

    /* Grab An Instance For Our Window */
    HInstance = GetModuleHandle(NULL);
    /* Redraw On Move, And Own DC For Window */
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    /* WndProc Handles Messages */
    wc.lpfnWndProc = (WNDPROC)WndProc;
    /* No Extra Window Data */
    wc.cbClsExtra = 0;
    /* No Extra Window Data */
    //wc.cbWndExtra = 0;
    /* Extra Window Data for modeless dialog box */
    wc.cbWndExtra = DLGWINDOWEXTRA;
    /* Set The Instance */
    wc.hInstance = HInstance;
    /* Load The Default Icon */
    wc.hIcon = LoadIcon(
        HInstance, MAKEINTRESOURCE(IDC_WIN32OPENGL));
    wc.hIconSm = LoadIcon(
        wc.hInstance, MAKEINTRESOURCE(IDC_MYICON));
    //wc.hIcon = LoadIcon(HInstance, MAKEINTRESOURCE(ID_MYICON));
    //wc.hIconSm = LoadIcon(HInstance, MAKEINTRESOURCE(ID_MYICON));
    /* Load The Arrow Pointer */
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    /* No Background Required For GL */
    wc.hbrBackground = nullptr;
    //wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    /* We Don't Want A Menu */
    wc.lpszMenuName = nullptr;
    /* to associate a menu with a window class, we need to include
    the name of the menu into the WNDCLASS structure.
    we use the MAKEINTRESOURCE keyword to convert the numerical
    identifier (IDM_MY_MENU) into an appropriate string pointer ;
    include the ID of our menu */
    //wc.lpszMenuName = MAKEINTRESOURCE(IDM_MY_MENU);
    /* Set The Class Name */
    wc.lpszClassName = L"OpenGL";

    /* Attempt To Register The Window Class */
    if (!RegisterClassExW(&wc))
    {
        /* error message */
    }

    #pragma endregion
    
    /* Window Extended Style */
    dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; 
    /* Windows Style */
    dwStyle = WS_OVERLAPPEDWINDOW; 

    /* Adjust Window To True Requested Size */
    AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); 

    static TCHAR WinClassName[] = _T("OpenGL win32app");
    static TCHAR WinTitle[] = _T("OpenGL Application");

    /* Create the window - *** STEP 2 *** */
    #pragma region Create Window Extension

    RECT windRect = { 0, 0, winW, winH };
    AdjustWindowRectEx(
        &windRect, WS_OVERLAPPEDWINDOW,
        FALSE, WS_EX_OVERLAPPEDWINDOW);
    LONG initialWidth = windRect.right - windRect.left;
    LONG initialHeight = windRect.bottom - windRect.top;

    /* if window created hWnd will hold the window handle */
    if (!(hWnd = CreateWindowEx(
        /* Extended Style For The Window */
        dwExStyle,
        /* Class Name */
        L"OpenGL",
        /* Window Title*/
        WinTitle,
        /* Required Window Style  */
        WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
        /* Selected Window Style */
        dwStyle,
        /* Window Position */
        //0, 0, // CW_USEDEFAULT - set starting point to default
        ///* Calculate Adjusted Window Width */
        //WindowRect.right - WindowRect.left,
        ///* Calculate Adjusted Window Height */
        //WindowRect.bottom - WindowRect.top,
        (DesktopRect.right - winW) / 2, // pos x
        (DesktopRect.bottom - winH) / 2, // pos y
        winW, winH, // width, height
        /* No Parent Window */
        nullptr,
        /* No Menu */
        nullptr,
        /* once we have the HMENU handle to the menu, we can supply
        it to our CreateWindow function, so that the menu is
        created when the window is created */
        //hmenu,
        /* Instance */
        HInstance,
        /* pass a pointer to structure */
        pState
        //NULL // Don't Pass Anything To WM_CREATE
    ))) {
        /* ReleaseGLWindow */
    }

    #pragma endregion

    /*BOOL value = TRUE;
    ::DwmSetWindowAttribute(
        hWnd, DWMWA_USE_IMMERSIVE_DARK_MODE,
        &value, sizeof(value));*/

    // Slightly Higher Priority
    SetForegroundWindow(hWnd);
    // Sets Keyboard Focus To The Window
    SetFocus(hWnd);

    // Show The Window
    ShowWindow(hWnd, SW_SHOW);

    UsingD3D();
    createVertexShader();
    
    return TRUE; // Success
    
}

// int WINAPI WinMain() { }
int APIENTRY wWinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ PWSTR lpCmdLine, 
    _In_ int nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Place code here.
    BOOL done = FALSE;
    bool test = true;

    if (test) {

        MSG msg;
        // Create Window
        if (!CreateWindow(cnvrt, winW, winH, bits))
        {
            /* error message */
        }

        /* *** STEP 3 ***/
        while (!done) { 
            /* Is There A Message Waiting? */
            if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
                /* We Received A Quit Message */
                if (msg.message == WM_QUIT) {
                    done = TRUE;
                }
                else {
                    /* The TranslateMessage function is 
                    related to keyboard input. It translates 
                    keystrokes (key down, key up) into 
                    characters. */
                    /* Translate The Message */
                    TranslateMessage(&msg);
                    /* The DispatchMessage function tells 
                    the operating system to call the window 
                    procedure of the window that is the 
                    target of the message. */
                    /* Dispatch The Message */
                    DispatchMessage(&msg);
                }
            }
            else { // if there were no messages...
                if (active) { // if Program Active...
                    /* Watch For ESC Key And Quit Messages */
                    if (keys[VK_ESCAPE]) // if ESC Pressed...
                    {
                        done = TRUE;
                    }
                    else {
                        if (d3dRend) {
                            d3dDrawShape();
                        }
                    }
                }
            }
        }

        // Shutdown
        // Release Window
        return ((int)msg.wParam); // Exit The Program
    }
}

LRESULT CALLBACK WndProc(
    HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_CREATE:
        {
            winHDC = GetDC(hWnd);

            RECT rcClient, rcFrame;
            GetWindowRect(hWnd, &rcFrame);
            GetClientRect(hWnd, &rcClient);
        }
        case WM_ACTIVATE: // Watch For Window Activate Message
        {
            if (!HIWORD(wParam)) // Check Minimization State
            {
                active = TRUE; // Program Is Active
            }
            else
            {
                active = FALSE; // Program Is No Longer Active
            }
        }
        case WM_SYSCOMMAND: // Intercept System Commands
        {
            switch (wParam) // Check System Calls
            {
                // Screensaver Trying To Start?
                case SC_SCREENSAVE: 
                // Monitor Entering Powersave?
                case SC_MONITORPOWER: 
                return 1; // Allow
                //return 0; // Prevent From Happening
            }
        }
        case WM_SIZE: // Resize the Window
        {
            
        }
        case WM_COMMAND:
        {
            wmId = LOWORD(wParam);
            wmEvent = HIWORD(wParam);
        }
        break;
        /* Windows should respond to WM_PAINT & WM_PRINTCLIENT */
        case WM_PRINTCLIENT: 
        {
            OnPaint((HDC)wParam, NULL);
        }
        break;
        case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);

            // TODO: Add any drawing code that uses hdc here
            OnPaint(ps.hdc, &ps.rcPaint);
            //DrawAndPaint(hdc);

            EndPaint(hWnd, &ps);
        }
        break;
        /* DefWindowProc automatically calls DestroyWindow. 
        That means if you ignore the WM_CLOSE message in 
        your switch statement, the window is destroyed by 
        default.*/
        case WM_CLOSE:
        /*if (MessageBox(
            hWnd, L"Really quit?", L"Exit", 
            MB_OKCANCEL) == IDOK)*/
        {
            if (!canClose && test) { /* Release Window */
            }
            else { DestroyWindow(hWnd); }
        }
        break;
        case WM_DESTROY:
        {
            /* exit application and break out of message loop */
            PostQuitMessage(0);
        }
        break;
        default:
            /* // Pass All Unhandled Messages To DefWindowProc */
            return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

Let me know if you get any errors

1 answer

Xiaopo Yang - MSFT 12,726 Reputation points Microsoft Vendor

2023-03-23T02:29:38.1+00:00

Hello @JWG ,

Welcome to Microsoft Q&A!

Your DXGI_SWAP_CHAIN_DESC1 Width and Height is set with wrong value and ID3D11DeviceContext::RSSetViewports is only called at Initialization and after Resized. For how to use, see Interactive3dTextSample. The attached code failed to compile.

Thank you.
Please sign in to rate this answer.
JWG 146 Reputation points

2023-03-23T13:40:10.36+00:00

@xiaopo yang I have decided to start over from scratch. I already have the samples, and will use them. Thanks for your effort.

Xiaopo Yang - MSFT 12,726 Reputation points Microsoft Vendor

2023-03-24T01:53:07.39+00:00

@JWG You're welcome.
Sign in to comment

Use comments to ask for clarification, additional information, or improvements to the question.

Share via

How do I fix dll exception in win32 app?

1 answer

Your answer