C++ [D3D11] - 奇怪的行为，函数被调用了 2 次

Question

THE SCENE:
So, I have been learning D3D11 programming for the last 15 days now using "3d game programming with DirectX11" book by Frank Luna. I had done pretty well upto now. But because the book uses a deprecated D3DX11 library, I had to devise my own functions as replacement.

One of it is a function to compile shaders. It is like this-
Helpers.cpp

#include "Helpers.h"


HRESULT CompileShader(LPCWSTR srcFile, LPCSTR entryPoint, LPCSTR profile, ID3DBlob** blob)
{
    if(!srcFile || !entryPoint || !profile || !blob)
        return E_INVALIDARG;

    *blob = nullptr;

    UINT flags = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined(DEBUG) || defined(_DEBUG)
    flags |= D3DCOMPILE_DEBUG;
#endif

    ComPtr<ID3DBlob> errorBlob;

    HRESULT hr = D3DCompileFromFile(
        srcFile, nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, 
        entryPoint, profile, flags, 0, &blob, errorBlob.GetAddressOf());

    if(errorBlob.Get())
    {
        MessageBoxA(0, (char*)errorBlob->GetBufferPointer(), "Shader ERROR/WARNING", MB_ICONINFORMATION);
        errorBlob.Reset();
    }

    if(FAILED(hr))
    {
        (*blob)->Release();

        std::wostringstream ss;
        ss << L"Error in compiling shader: " << srcFile;
        MessageBox(0, ss.str().c_str(), L"ERROR", MB_ICONERROR);

        return hr;
    }

    return hr;
}

NOTE: The file Helpers.h includes nothing but this function declaration and some includes.

Some other helper functions/defines are:-

1. Framework for D3D11 base code :-
   In D3DApp.h
   

    class D3DApp { protected: //Win32 related HWND hWnd; HINSTANCE hInst; LPWSTR appName; LPWSTR const className; int wndWidth; int wndHeight; //Direct3D 11 related ComPtr<ID3D11Device> pDevice; ComPtr<ID3D11DeviceContext> pContext; ComPtr<IDXGISwapChain> pSwapChain; ComPtr<ID3D11RenderTargetView> pRenderTargetView; ComPtr<ID3D11DepthStencilView> pDepthStencilView; ComPtr<ID3D11Texture2D> pDepthStencilBuffer; D3D11_VIEWPORT viewport; //Can be used to tweak d3d11 settings bool enable4xMSAA; bool enableFullscreen; //App states bool isAppPaused; bool isResizing; //Others Timer timer; FrameStats stats; bool isDestroyed; public: D3DApp(); ~D3DApp(); virtual bool init(); virtual bool onResize(); virtual void update(float dt) = 0; virtual void render() = 0; virtual void destroy(); virtual void run(); virtual LRESULT msgProc(HWND, UINT, WPARAM, LPARAM); virtual void onMouseDown(WPARAM btnState, int x, int y) {} virtual void onMouseUp(WPARAM btnState, int x, int y) {} virtual void onMouseMove(WPARAM btnState, int x, int y) {} virtual void onKeyDown(WPARAM keyState) {}; virtual void onKeyUp(WPARAM keyState) {}; private: //Implementation meant to be hidden //Not needed to be changed often bool _initWindow(); bool _initD3D(); }; extern D3DApp* gD3DApp; LRESULT CALLBACK gMsgProc(HWND, UINT, WPARAM, LPARAM);

2. define to declare main() :-
   In D3DApp.h
   

    #ifndef IMPLEMENT_D3DAPP_MAIN #define IMPLEMENT_D3DAPP_MAIN(childClass) \\ INT CALLBACK WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, INT nShowCmd) \\ { \\ childClass app; \\ try { \\ if(!app.init()) \\ { \\ app.destroy(); \\ return 1; \\ } \\ app.run(); \\ } \\ catch(std::exception& e) \\ { \\ OutputDebugStringA(e.what()); \\ MessageBoxA(0, e.what(), "ERROR", MB_ICONERROR); \\ app.destroy(); \\ return 1; \\ } \\ app.destroy(); \\ return 0; \\ } #endif //IMPLEMENT_D3DAPP_MAIN

3. And define for quick error checking :-
   In D3DApp.h
   

   #define HR(hr) \\ if(FAILED(hr)) { \\ std::ostringstream ss; \\ ss << "FILE: " << __FILE__ << std::endl << std::endl; \\ ss << "LINE: " << __LINE__ << std::endl << std::endl; \\ ss << "HRESULT = " << (hr) << std::endl; \\ throw std::exception(ss.str().c_str()); \\ }

It works like when a function call fails. It is detected by HR() and it throws an std::exception, which is then caught in WinMain() try-catch block. Then the user can see the error in a MessageBox.

It should work nicely.

But in my app :-
In main.cpp

#include "../Common/D3DApp.h"
#include "../Common/Helpers.h"
#include <sstream>
#include <DirectXMath.h>
#include <DirectXColors.h>


using namespace DirectX;


class Drawing : public D3DApp
{
public:
    ComPtr<ID3D11PixelShader> PS;
    ComPtr<ID3D11VertexShader> VS;

public:
    bool init() override
    {
        appName = L"Drawing in D3D11";
        if(!D3DApp::init())
            return false;

        //////////////////////////////////////////
        //////////////SHADERS////////////////////
        ComPtr<ID3DBlob> shaderBytecode;

        HR(CompileShader(L"simple.lsl", "VSMain", "vs_5_0", shaderBytecode.GetAddressOf()));
        HR(pDevice->CreateVertexShader(shaderBytecode->GetBufferPointer(), shaderBytecode->GetBufferSize(), nullptr, VS.GetAddressOf()));
        shaderBytecode.Reset();

        HR(CompileShader(L"simple.hlsl", "PSMain", "ps_5_0", shaderBytecode.GetAddressOf()));
        HR(pDevice->CreatePixelShader(shaderBytecode->GetBufferPointer(), shaderBytecode->GetBufferSize(), nullptr, PS.GetAddressOf()));
        shaderBytecode.Reset();
        //////////////SHADERS////////////////////

        //////////////SET STATES////////////////
        pContext->PSSetShader(PS.Get(), nullptr, 0);
        pContext->VSSetShader(VS.Get(), nullptr, 0);

        pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        //////////////SET STATES////////////////

        /////////////////////////////////////////

        return true;
    }

    void update(float deltaTime) override
    {
    }

    void render() override
    {
        const float clearColour[4] = {0.f, 0.f, 1.f, 1.f};
        pContext->ClearRenderTargetView(pRenderTargetView.Get(), clearColour);
        pContext->ClearDepthStencilView(pDepthStencilView.Get(), D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.f, 1);

        pContext->Draw(3, 0);

        HR_PRESENT(pSwapChain->Present(0, 0));
    }

    void destroy() override
    {
        VS.Reset();
        PS.Reset();

        D3DApp::destroy();
    }
};

IMPLEMENT_D3DAPP_MAIN(Drawing);

To test the HR() define, I purposely invalidated a function argument from "simple.hlsl" to "simple.lsl" , as you can see when compiling the vertex shader.

THE RESULT:
1. The window is created. [OK]
2. A popup says, "Error in compiling shader: simple.lsl" [OK]
3. [Clicked ok]
4. Again the same popup shows with same message [WTH?]
5. [Clicked ok]
6. Last popup of try-catch block, describing the file, line and HRESULT of the error [OK]

Sorry, if my English is bland.
This may seem like a small problem. Yes, I can live with this. But it is very very annoying. Thanks for reading till here ;)
Thanks in advance.

Answer 1

Lets look at the HR macro:

#define HR(hr) \
if(FAILED(hr)) { \
    std::ostringstream ss; \
    ss << "FILE: " << __FILE__ << std::endl << std::endl; \
    ss << "LINE: " << __LINE__ << std::endl << std::endl; \
    ss << "HRESULT = " << (hr) << std::endl; \
    throw std::exception(ss.str().c_str()); \
}

You use the "argument" hr twice in the function, once in FAILED(hr) and once when you print the result. That means hr will be evaluated twice. If you use a function call as the macro argument then the function will be called twice.

The reason for this is because macros are not "called" at run-time, instead they replace the code before the C++ parser gets to the code.

This is one major reason macros are often frowned upon, especially in C++.

Answer 2

Expand HR(CompileShader(L"simple.lsl", "VSMain", "vs_5_0", shaderBytecode.GetAddressOf())); :

if(FAILED(CompileShader(L"simple.lsl", "VSMain", "vs_5_0", shaderBytecode.GetAddressOf())))) { \
    std::ostringstream ss; \
    ss << "FILE: " << __FILE__ << std::endl << std::endl; \
    ss << "LINE: " << __LINE__ << std::endl << std::endl; \
    ss << "HRESULT = " << (CompileShader(L"simple.lsl", "VSMain", "vs_5_0", shaderBytecode.GetAddressOf()))) << std::endl; \
    throw std::exception(ss.str().c_str()); \
};

You can see the problem now.

Since you want __FILE__ and __LINE__ , you can use a function that takes the file and line as parameters

void HR_check(HRESULT hr, const char* file, int line)
{
    if (FAILED(hr)) {
        std::ostringstream ss;
        ss << "FILE: " << file << std::endl << std::endl;
        ss << "LINE: " << line << std::endl << std::endl;
        ss << "HRESULT = " << hr << std::endl;
        throw std::exception(ss.str().c_str());
    }
}

and combine it with a macro:

#define HR(fn) HR_check(fn, __FILE__, __LINE__)