spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void __cdecl _free_base (void * pBlock)
{

        int retval = 0;


        if (pBlock == NULL)
            return;

        RTCCALLBACK(_RTC_Free_hook, (pBlock, 0));

        retval = HeapFree(_crtheap, 0, pBlock);
        if (retval == 0)  // Zeile 51
        {
            errno = _get_errno_from_oserr(GetLastError());
        }
}

C-/C++-Quelltext

Result Effect::InitFromString(string sCode, int iCodeSize)
{
    if(sCode == "")
        LOG_ERROR("Invalid shader code", NXE_ERROR);

    DWORD shaderFlags = 0;

#ifdef _DEBUG
    shaderFlags |= D3D10_SHADER_DEBUG;
    shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif

    NXETerminal::DebugWrite("Compile shader");

    ID3D10Blob* compiledShader = 0;
    ID3D10Blob* compilationMsgs = 0;

    HRESULT hr = D3DCompile(sCode.c_str(), iCodeSize, "CompiledShaderFromCode", NULL, NULL, NULL, "fx_5_0", shaderFlags, 0, &compiledShader, &compilationMsgs);

    if(compilationMsgs)
    {
        Log::WriteDirect2("D3DCompile throws:\n%s", static_cast<const char*>(compilationMsgs->GetBufferPointer()));
        SAFE_RELEASE(compilationMsgs);

        NXETerminal::StopError();

        return NXE_ERROR;
    }

    if(FAILED(hr))
        LOG_ERROR_DIRECTX("D3DCompile", hr, NXE_ERROR);

    hr = D3DX11CreateEffectFromMemory(compiledShader->GetBufferPointer(), compiledShader->GetBufferSize(), 0, Direct3D::Instance().GetDevice(), &m_pEffect);
    if(FAILED(hr))
        LOG_ERROR_DIRECTX("D3DX11CreateEffectFromMemory", hr, NXE_ERROR);

    SAFE_RELEASE(compiledShader);

    m_pEffect->GetDesc(&m_Desc);

    return NXE_OK;
}

Quellcode

541B0D80  push        ebp  
541B0D81  mov         ebp,esp  
541B0D83  push        0FFFFFFFFh  
541B0D85  push        5425B79Bh  
541B0D8A  mov         eax,dword ptr fs:[00000000h]  
541B0D90  push        eax  
541B0D91  sub         esp,0B8h  
541B0D97  push        esi  
541B0D98  push        edi  
541B0D99  mov         eax,dword ptr ds:[542BA064h]  
541B0D9E  xor         eax,ebp  
541B0DA0  push        eax  
541B0DA1  lea         eax,[ebp-0Ch]  
541B0DA4  mov         dword ptr fs:[00000000h],eax  
541B0DAA  mov         edi,ecx  
541B0DAC  lea         ecx,[ebp-0C0h]  
541B0DB2  call        D3DX11Effects::CEffectLoader::CEffectLoader (541A6610h)  
541B0DB7  mov         eax,dword ptr [ebp+8]  
541B0DBA  mov         dword ptr [ebp-4],0  
541B0DC1  test        eax,eax  
541B0DC3  jne         D3DX11Effects::CEffect::LoadEffect+4Ch (541B0DCCh)  
541B0DC5  mov         esi,80070057h  
541B0DCA  jmp         D3DX11Effects::CEffect::LoadEffect+62h (541B0DE2h)  
541B0DCC  push        dword ptr [ebp+0Ch]  
541B0DCF  lea         ecx,[ebp-0C0h]  
541B0DD5  push        eax  
541B0DD6  push        edi  
541B0DD7  call        D3DX11Effects::CEffectLoader::LoadEffect (541B14F0h)  
541B0DDC  mov         esi,eax  
541B0DDE  test        esi,esi  
541B0DE0  jns         D3DX11Effects::CEffect::LoadEffect+69h (541B0DE9h)  
541B0DE2  mov         ecx,edi  
541B0DE4  call        D3DX11Effects::CEffect::ReleaseShaderRefection (541A3BA0h)  
541B0DE9  lea         ecx,[ebp-0C0h]  
541B0DEF  mov         dword ptr [ebp-4],0FFFFFFFFh  
541B0DF6  call        D3DX11Effects::CEffectLoader::~CEffectLoader (541A66A0h)

Quellcode

54A4A840  push        edi  
54A4A841  mov         edi,dword ptr [ecx]  
54A4A843  test        edi,edi  
54A4A845  je          CDataBlockStore::~CDataBlockStore+51h (54A4A891h)  
54A4A847  push        ebx  
54A4A848  push        esi  
54A4A849  lea         esp,[esp]  
54A4A850  lea         esi,[edi+0Ch]  
54A4A853  mov         ebx,edi  
54A4A855  mov         edi,dword ptr [esi]  
54A4A857  mov         dword ptr [esi],0  
54A4A85D  push        dword ptr [ebx+8]  
54A4A860  call        dword ptr ds:[54AF1324h]

C-/C++-Quelltext

Result Direct3D::Init(Config* pConfig, 
                          char* pcWindowTitle, 
                          HWND hOwnWindow,      // = NULL
                          HICON hIcon,          // = NULL
                          bool bShowCursor)     // = false
{
    m_bInitialized = false;
    m_bOwnWindow = false;
    m_hWindow = NULL;
    m_pIDXGIFactory = NULL;
    m_pD3D11Device = NULL;
    m_pD3DImmediateContext = NULL;
    m_pSwapChain = NULL;
    m_pRenderTargetView = NULL;
    m_pDepthStencilView = NULL;
    m_pDepthStencilBuffer = NULL;
    m_pBackBuffer = NULL;
    m_pStandardEffect = NULL;
    m_pTmpEffect = NULL;
    m_bMulitSampling = false;

    if(!hIcon) hIcon = LoadIcon(NoxetEngine::g_DLLHandle, MAKEINTRESOURCE(IDI_ICON1));

    HRESULT                 hResult;
    WNDCLASSEX              WindowClass = {sizeof(WNDCLASSEX), CS_CLASSDC, WindowProc, 0, 0, 
                                           NoxetEngine::g_DLLHandle, hIcon, LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW)), 
                                           NULL, NULL, "Direct3D Window Class", NULL};

    if(!pConfig) LOG_ERROR_NULL_POINTER("pConfig", NXE_ERROR);

    m_vScreenSize.x = (float)(pConfig->Direct3D.VideoMode.Width);
    m_vScreenSize.y = (float)(pConfig->Direct3D.VideoMode.Height);

    m_bOwnWindow = hOwnWindow != NULL;
    if(m_bOwnWindow) m_hWindow = hOwnWindow;

    if(!g_hWindow)
    {
        if(!m_bOwnWindow)
        {
            if(!RegisterClassEx(&WindowClass))
            {
                // Fehler
                LOG_ERROR("Could not register window class", NXE_ERROR);
            }

            int iWidth = pConfig->Direct3D.VideoMode.Width;
            int iHeight = pConfig->Direct3D.VideoMode.Height;

            RECT Rect;
            SetRect(&Rect, 0, 0, iWidth, iHeight);
            AdjustWindowRect(&Rect, WS_VISIBLE | WS_OVERLAPPEDWINDOW, FALSE);
            iWidth = Rect.right - Rect.left;
            iHeight = Rect.bottom - Rect.top;

            // Fenster erstellen
            m_hWindow = CreateWindow("Direct3D Window Class", 
                                     pcWindowTitle, 
                                     WS_VISIBLE | WS_OVERLAPPEDWINDOW, 
                                     GetSystemMetrics(SM_CXSCREEN) / 2 - iWidth / 2, 
                                     GetSystemMetrics(SM_CYSCREEN) / 2 - iHeight / 2, 
                                     iWidth, 
                                     iHeight, 
                                     NULL, 
                                     NULL, 
                                     NoxetEngine::g_DLLHandle, 
                                     NULL);
            if(!m_hWindow)
            {
                ERROR_BOX("Could not create window", "Error");
                LOG_ERROR("Could not create window", NXE_ERROR);
            }
        }

        g_hWindow = m_hWindow;
    }
    else
        m_hWindow = g_hWindow;

    UINT createDeviceFlags = 0;

#ifdef _DEBUG
    #ifdef D3D11_DEVICE_DEBUG
    createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
    #endif
#endif

    hResult = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&m_pIDXGIFactory);
    if(FAILED(hResult))
        LOG_ERROR_DIRECTX("CreateDXGIFactory1", hResult, NXE_ERROR);

    IDXGIAdapter1* pAdapter;
    hResult = m_pIDXGIFactory->EnumAdapters1(pConfig->Direct3D.iAdapter, &pAdapter);

    if(FAILED(hResult))
        LOG_ERROR_DIRECTX("EnumAdapters1", hResult, NXE_ERROR);

    D3D_FEATURE_LEVEL featureLevel;
    hResult = D3D11CreateDevice(
            pAdapter,
            D3D_DRIVER_TYPE_UNKNOWN,
            0,
            createDeviceFlags, 
            0, 0,
            D3D11_SDK_VERSION,
            &m_pD3D11Device,
            &featureLevel,
            &m_pD3DImmediateContext);

    if(FAILED(hResult))
    {
        ERROR_BOX("D3D11CreateDevice Failed.", "Error");
        SAFE_RELEASE(pAdapter);
        LOG_ERROR_DIRECTX("D3D11CreateDevice", hResult, NXE_ERROR);
    }

    if(featureLevel != D3D_FEATURE_LEVEL_11_0)
    {
        LOG_WARNING("Direct3D Feature Level 11 unsupported");

        if(featureLevel != D3D_FEATURE_LEVEL_10_1 && featureLevel != D3D_FEATURE_LEVEL_10_0)
        {
            ERROR_BOX("DirectX 10.0 not supported!", "Error");
            LOG_ERROR_MESSAGE("DirectX 10.0 not supported!");
            SAFE_RELEASE(pAdapter);
            return NXE_ERROR;
        }
    }

    if(!m_pD3D11Device || !m_pD3DImmediateContext)
    {
        ERROR_BOX("D3D11CreateDevice Failed.", "Error");
        SAFE_RELEASE(pAdapter);
        LOG_ERROR("D3D11CreateDevice Failed.", NXE_ERROR);
    }

    DXGI_SWAP_CHAIN_DESC sd;
    ZeroMemory(&sd, sizeof(DXGI_SWAP_CHAIN_DESC));

    sd.BufferDesc.Width  = (int)m_vScreenSize.x;
    sd.BufferDesc.Height = (int)m_vScreenSize.y;
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
    sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
    sd.BufferUsage  = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    sd.BufferCount  = 1;
    sd.OutputWindow = m_hWindow;
    sd.SwapEffect   = DXGI_SWAP_EFFECT_DISCARD;
    sd.Flags        = /*DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH*/0;
    sd.Windowed     = pConfig->Direct3D.bWindowed;
    if(pConfig->Direct3D.MultiSamplingSamples == 0)
    {
        pConfig->Direct3D.MultiSamplingSamples = 1;
        pConfig->Direct3D.MultiSamplingQuality = 0;
    }
    sd.SampleDesc.Count   = pConfig->Direct3D.MultiSamplingSamples;
    sd.SampleDesc.Quality = pConfig->Direct3D.MultiSamplingQuality;
    if(pConfig->Direct3D.bVSync)
    {
        sd.BufferDesc.RefreshRate.Numerator = 60;
        sd.BufferDesc.RefreshRate.Denominator = 1;
    }
    else
    {
        sd.BufferDesc.RefreshRate.Numerator = 0;
        sd.BufferDesc.RefreshRate.Denominator = 1;
    }

    hResult = m_pIDXGIFactory->CreateSwapChain(m_pD3D11Device, &sd, &m_pSwapChain);
    if(FAILED(hResult))
        LOG_ERROR_DIRECTX("m_pIDXGIFactory->CreateSwapChain", hResult, NXE_ERROR);

    m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&m_pBackBuffer);
    m_pD3D11Device->CreateRenderTargetView(m_pBackBuffer, 0, &m_pRenderTargetView);

    D3D11_TEXTURE2D_DESC depthStencilDesc;
    ZeroMemory(&depthStencilDesc, sizeof(D3D11_TEXTURE2D_DESC));

    depthStencilDesc.Width     = (int)m_vScreenSize.x;
    depthStencilDesc.Height    = (int)m_vScreenSize.y;
    depthStencilDesc.MipLevels = 1;
    depthStencilDesc.ArraySize = 1;
    depthStencilDesc.Format    = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilDesc.SampleDesc.Count   = pConfig->Direct3D.MultiSamplingSamples;
    depthStencilDesc.SampleDesc.Quality = pConfig->Direct3D.MultiSamplingQuality;
    depthStencilDesc.Usage          = D3D11_USAGE_DEFAULT;
    depthStencilDesc.BindFlags      = D3D11_BIND_DEPTH_STENCIL;
    depthStencilDesc.CPUAccessFlags = 0; 
    depthStencilDesc.MiscFlags      = 0;

    hResult = m_pD3D11Device->CreateTexture2D(&depthStencilDesc, 0, &m_pDepthStencilBuffer);
    if(FAILED(hResult))
        LOG_ERROR_DIRECTX("m_pD3D11Device->CreateTexture2D", hResult, NXE_ERROR);

    hResult = m_pD3D11Device->CreateDepthStencilView(m_pDepthStencilBuffer, 0, &m_pDepthStencilView);
    if(FAILED(hResult))
        LOG_ERROR_DIRECTX("m_pD3D11Device->CreateDepthStencilView", hResult, NXE_ERROR);

    m_pD3DImmediateContext->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);

    ZeroMemory(&m_ScreenViewport, sizeof(D3D11_VIEWPORT));
    m_ScreenViewport.TopLeftX = 0;
    m_ScreenViewport.TopLeftY = 0;
    m_ScreenViewport.Width    = m_vScreenSize.x;
    m_ScreenViewport.Height   = m_vScreenSize.y;
    m_ScreenViewport.MinDepth = 0.0f;
    m_ScreenViewport.MaxDepth = 1.0f;

    m_pD3DImmediateContext->RSSetViewports(1, &m_ScreenViewport);

    m_OwnConfig = *pConfig;

    NXETerminal::DebugWrite("Init Direct3D 11 (11.0) with IDXGIFactory 1.1");

    NXETerminal::DebugWrite("Create rasterizer states...");

    m_Fill = D3D11_FILL_SOLID;
    m_Cull = D3D11_CULL_BACK;
    m_bMulitSampling = pConfig->Direct3D.MultiSamplingSamples > 1 ? true:false;

    m_pTmpEffect = new Effect;

    SAFE_RELEASE(pAdapter);

    ShowCursor(bShowCursor);

string sDummyShader = "struct VertexIn"
                    "{"
                        "float3 Pos     : POSITION;"
                        "float3 Normal  : NORMAL;"
                        "float4 Tangent : TANGENT;"
                        "float2 Tex     : TEXCOORD;"
                    "};"
                    "struct VertexOut"
                    "{"
                        "float4 Pos : SV_POSITION;"
                    "};"
                    "VertexOut VS(VertexIn vin)"
                    "{"
                        "VertexOut vout;"
                        "vout.Pos.xyz = vin.Pos;"
                        "vout.Pos.w = 1.0f;"
                        "return vout;"
                    "}"
                    "float4 PS(VertexOut pin) : SV_Target"
                    "{"
                        "return float4(1.0f,1.0f,1.0f,1.0f);"
                    "}"
                    "technique11 DummyTech"
                    "{"
                        "pass P0"
                        "{"
                            "SetVertexShader( CompileShader( vs_5_0, VS() ) );"
                            "SetGeometryShader( NULL );"
                            "SetPixelShader( CompileShader( ps_5_0, PS() ) );"
                        "}"
                    "}";

    int s = strlen(sDummyShader.c_str());
    m_pTmpEffect->InitFromString(sDummyShader, s);

    return NXE_OK;
}

Quellcode

===========================================================
VERIFIER STOP 00000010: pid 0x1A60: corrupted start stamp 

    00351000 : Heap handle
    08881000 : Heap block
    C0C0C0C0 : Block size
    C0C0C0C0 : Corrupted stamp
===========================================================
This verifier stop is not continuable. Process will be terminated 
when you use the `go' debugger command.
===========================================================