처리되지 않은 예외 오류 초기화 다이렉트 X 11

Question

내가 초기화하려고 및 DirectX 11, 나는 다음과 같은 오류가 발생하면서 :

오류 :

에는 구문 오류가없는 물론

'Engine.exe': Loaded 'C:\Users\JayRavi\Desktop\Directx 11 Tutorials\Engine\Debug\Engine.exe', Symbols loaded. 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\ntdll.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\kernel32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\KernelBase.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\user32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\gdi32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\lpk.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\usp10.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\msvcrt.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\advapi32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\sechost.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\rpcrt4.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\sspicli.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\cryptbase.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\dxgi.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\version.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\dwmapi.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\d3d11.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\d3dx10_43.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\ole32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\msvcr100d.dll', Symbols loaded. 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\imm32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\msctf.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\nvinit.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Program Files (x86)\NVIDIA Corporation\coprocmanager\detoured.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Program Files (x86)\NVIDIA Corporation\coprocmanager\Nvd3d9wrap.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\setupapi.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\cfgmgr32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\oleaut32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\devobj.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Program Files (x86)\NVIDIA Corporation\coprocmanager\nvdxgiwrap.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\uxtheme.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\ProgramData\Real\RealPlayer\BrowserRecordPlugin\Chrome\Hook\rpchrome150browserrecordhelper.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\winsxs\x86_microsoft.vc90.crt_1fc8b3b9a1e18e3b_9.0.30729.6161_none_50934f2ebcb7eb57\msvcr90.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\shell32.dll', Cannot find or open the PDB file 
'Engine.exe': Loaded 'C:\Windows\SysWOW64\shlwapi.dll', Cannot find or open the PDB file 
First-chance exception at 0x00cb2efe in Engine.exe: 0xC0000005: Access violation writing location 0x00000000. 
Unhandled exception at 0x773315de in Engine.exe: 0xC0000005: Access violation writing location 0x00000000. 
The program '[5604] Engine.exe: Native' has exited with code -1073741819 (0xc0000005). 

. OS : Windows 7 Premium 64 비트. 다이렉트 X 버전 : 11 (물론, 대만족!) IDE : 비주얼 스튜디오 2010 (VC++)

코드 :

"d3dclass.h"

 #ifndef _D3DCLASS_H_ 
     #define _D3DCLASS_H_ 

     //Linking libraries for direct 3d 

     #pragma comment(lib, "dxgi.lib") 
     #pragma comment(lib, "d3d11.lib") 
     #pragma comment(lib, "d3dx11.lib") 
     #pragma comment(lib, "d3dx10.lib") 

     #include <dxgi.h> 
     #include <D3Dcommon.h> 
     #include <d3d11.h> 
     #include <D3DX10.h> 


     class D3DClass 
     { 
     public: 
      D3DClass(); 
      D3DClass(const D3DClass&); 
      ~D3DClass(); 

      bool Initialize(int, int, bool, HWND, bool, float,float); 
      void Shutdown(); 

      void BeginScene(float, float, float, float); 
      void EndScene(); 

      ID3D11Device* GetDevice(); 
      ID3D11DeviceContext* GetDeviceContext(); 

      void GetProjectionMatrix(D3DXMATRIX&); 
      void GetWorldMatrix(D3DXMATRIX&); 
      void GetOrthoMatrix(D3DXMATRIX&); 

      void GetVideoCardInfo(char*, int&); 

     private: 
      bool       m_vsync_enabled; 
      int        m_videoCardMemory; 
      char       m_videoCardDescription[128]; 
      IDXGISwapChain*     m_swapChain; 
      ID3D11Device*     m_device; 
      ID3D11DeviceContext*   m_deviceContext; 
      ID3D11RenderTargetView*   m_renderTargetView; 
      ID3D11Texture2D*    m_depthStencilBuffer; 
      ID3D11DepthStencilState*  m_depthStencilState; 
      ID3D11DepthStencilView*   m_depthStencilView; 
      ID3D11RasterizerState*   m_rasterState; 
      D3DXMATRIX      m_projectionMatrix; 
      D3DXMATRIX      m_worldMatrix; 
      D3DXMATRIX      m_orthoMatrix; 

     }; 
     #endif 

"d3dclass.cpp"

약간의 업데이트를

#include "d3dclass.h" 

D3DClass::D3DClass() 
{ 
    m_swapChain    = 0; 
    m_device     = 0; 
    m_deviceContext   = 0; 
    m_renderTargetView  = 0; 
    m_depthStencilBuffer  = 0; 
    m_depthStencilState  = 0; 
    m_depthStencilView  = 0; 
    m_rasterState   = 0; 
} 

D3DClass::D3DClass(const D3DClass& other) 
{ 
} 
D3DClass::~D3DClass() 
{ 
} 


bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, 
         HWND hwnd, bool fullscreen, float screenDepth, float screenNear) 

{ 
    HRESULT        result; 
    IDXGIFactory*      factory; 
    IDXGIAdapter*      adapter; 
    IDXGIOutput*      adapterOutput; 
    unsigned int      numModes, i, numerator, denominator, stringLength; 
    DXGI_MODE_DESC*      displayModeList; 
    DXGI_ADAPTER_DESC     adapterDesc; 
    int         error; 
    DXGI_SWAP_CHAIN_DESC    swapChainDesc; 
    D3D_FEATURE_LEVEL     featureLevel; 
    ID3D11Texture2D*     backBufferPtr; 
    D3D11_TEXTURE2D_DESC    depthBufferDesc; 
    D3D11_DEPTH_STENCIL_DESC   depthStencilDesc; 
    D3D11_DEPTH_STENCIL_VIEW_DESC  depthStencilViewDesc; 
    D3D11_RASTERIZER_DESC    rasterDesc; 
    D3D11_VIEWPORT      viewport; 
    float        fieldOfView, screenAspect; 

    //store the vsync setting. 
    m_vsync_enabled = vsync; 

    //Create a directX graphics interface factory 
    result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); 
    if(FAILED(result)) 
    { 
     return false; 
    } 
    //Use the factory to create an adapter for the primary graphics interface(video card). 
    result = factory->EnumAdapters(0, &adapter); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Enumerate the primary adapter output (monitor). 
    result = adapter->EnumOutputs(0, &adapterOutput); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output(monitor). 
    result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //create a list to hold all the possible display modes for this monitor/video card combination 
    displayModeList = new DXGI_MODE_DESC[numModes]; 
    if(!displayModeList) 
    { 
     return false; 
    } 

    //Now fill the display mode list strutures 
    result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Now go through all the display modes and find the one that matches the 
    //screen width and height. When a match is found store the numerator and 
    //denominator of the refresh rate for that monitor. 
    for(i=0; i<numModes; i++) 
    { 
     if(displayModeList[i].Width == (unsigned int)screenWidth) 
     { 
      if(displayModeList[i].Height == (unsigned int)screenHeight) 
      { 
       numerator = displayModeList[i].RefreshRate.Numerator; 
       denominator = displayModeList[i].RefreshRate.Denominator; 
      } 
     } 
    } 

    //Get the adapter (video card) description 
    result = adapter->GetDesc(&adapterDesc); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Store the dedicated video card memory in megabytes. 
    m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory/1024/1024); 

    //Convert the name of the video card to a character array and store it. 
    error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128); 
    if(error!=0) 
    { 
     return false; 
    } 

    //Release the display mode list. 
    delete [] displayModeList; 
    displayModeList = 0; 

    //Release the adapter output. 
    adapterOutput->Release(); 
    adapterOutput = 0; 

    //Release the adapter. 
    adapter->Release(); 
    adapter = 0; 

    //Release the factory. 
    factory->Release(); 
    factory = 0; 

    //Initialize the swap chain description. 
    ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); 

    //Set to a single back buffer. 
    swapChainDesc.BufferCount = 1; 

    //Set the width and height of the back buffer. 
    swapChainDesc.BufferDesc.Width = screenWidth; 
    swapChainDesc.BufferDesc.Height = screenHeight; 

    //Set regular 32Bit surface for the back buffer. 
    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; 

    //Set the refresh rate of the back buffer. 
    if(m_vsync_enabled) 
    { 
     swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator; 
     swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator; 
    } 
    else 
    { 
     swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; 
     swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; 
    } 

    //Set the usage of the back buffer. 
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; 

    //set the handle for the window to render to . 
    swapChainDesc.OutputWindow = hwnd; 

    //turn multisampling off. 
    swapChainDesc.SampleDesc.Count = 1; 
    swapChainDesc.SampleDesc.Quality = 0; 

    //Set to full screen or windowed mode. 
    if(fullscreen) 
    { 
     swapChainDesc.Windowed = false; 
    } 
    else 
    { 
     swapChainDesc.Windowed = true; 
    } 

    //Set the scan line ordering and scaling to unspecified. 
    swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; 
    swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; 

    //Discard the back buffer contents after presenting. 
    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; 

    //Dont set the advanced flags. 
    swapChainDesc.Flags = 0; 

    //Set the feature level to DirectX 11. 
    featureLevel = D3D_FEATURE_LEVEL_11_0; 

    //Create the swap chain, Direct 3D device and direct 3d device context. 
    result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL,0, 
           &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext); 

    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Get the pointer to the back buffer. 
    result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Create the render target view with the back buffer pointer. 
    result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Release pointer to the back buffer as we no longer need it. 
    backBufferPtr->Release(); 
    backBufferPtr = 0; 

    //Initialize the description of the depth buffer. 
    ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); 

    //Set up the description of the depth buffer. 
    depthBufferDesc.Width = screenWidth; 
    depthBufferDesc.Height = screenHeight; 
    depthBufferDesc.MipLevels = 1; 
    depthBufferDesc.ArraySize = 1; 
    depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; 
    depthBufferDesc.SampleDesc.Count = 1; 
    depthBufferDesc.SampleDesc.Quality = 0; 
    depthBufferDesc.Usage = D3D11_USAGE_DEFAULT; 
    depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; 
    depthBufferDesc.CPUAccessFlags = 0; 
    depthBufferDesc.MiscFlags = 0; 

    //Create the texture for the depth buffer using the filled out description. 
    result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Initialize the description of the stencil state. 
    ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc)); 

    //Set up the description of the stencil state. 
    depthStencilDesc.DepthEnable = true; 
    depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; 
    depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS; 

    depthStencilDesc.StencilEnable = true; 
    depthStencilDesc.StencilReadMask = 0xFF; 
    depthStencilDesc.StencilWriteMask = 0xFF; 

    //Stencil operations if pixel is front facing. 
    depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; 
    depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR; 
    depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; 
    depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; 

    //Stencil operations if pixel is back-facing. 
    depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; 
    depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR; 
    depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; 
    depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; 

    //Create the depth stencil state. 
    result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Set the depth stencil state. 
    m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1); 

    //Initialize the depth stencil view. 
    ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); 

    //Set up the depth Stencil view description. 
    depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; 
    depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; 
    depthStencilViewDesc.Texture2D.MipSlice = 0; 

    //Create the depth stencil view. 
    result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Bind the render target view and depth stencil buffer to the output render pipeline. 
    m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView); 

    //Setup the raster description which will determine how and what polygons will be drawn 
    rasterDesc.AntialiasedLineEnable = false; 
    rasterDesc.CullMode = D3D11_CULL_BACK; 
    rasterDesc.DepthBias = 0; 
    rasterDesc.DepthBiasClamp = 0.0f; 
    rasterDesc.DepthClipEnable = true; 
    rasterDesc.FillMode = D3D11_FILL_SOLID; 
    rasterDesc.FrontCounterClockwise = false; 
    rasterDesc.MultisampleEnable = false; 
    rasterDesc.ScissorEnable = false; 
    rasterDesc.SlopeScaledDepthBias = 0.0f; 

    //Create the rasterizer state from the description we just filled out. 
    result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState); 
    if(FAILED(result)) 
    { 
     return false; 
    } 

    //Now set the rasterizer state. 
    m_deviceContext->RSSetState(m_rasterState); 

    //Setup the viewport for rendering. 
    viewport.Width = (float)screenWidth; 
    viewport.Height = (float)screenHeight; 
    viewport.MinDepth = 0.0f; 
    viewport.MaxDepth = 1.0f; 
    viewport.TopLeftX = 0.0f; 
    viewport.TopLeftY = 0.0f; 

    //Create the viewport. 
    m_deviceContext->RSSetViewports(1, &viewport); 

    //Setupthe project matrix. 
    fieldOfView = (float)D3DX_PI/4.0f; 
    screenAspect = (float)screenWidth/(float)screenHeight; 

    //Create the project matrix for 3D rendering. 
    D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth); 

    //Initialize the world matrix to the identity matrix. 
    D3DXMatrixIdentity(&m_worldMatrix); 

    //Create an orthographic projection matrix for 2D rendering. 
    D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth); 

    return true; 
} 

void D3DClass::Shutdown() 
{ 
    //Before shutting down set to windowed mode or when you release the swap chain 
    //it will throw an exception 

    if(m_swapChain) 
    { 
     m_swapChain->SetFullscreenState(false,NULL); 
    } 

    if(m_rasterState) 
    { 
     m_rasterState->Release(); 
     m_rasterState = 0; 
    } 

    if(m_depthStencilView) 
    { 
     m_depthStencilView->Release(); 
     m_depthStencilView = 0; 
    } 

    if(m_depthStencilState) 
    { 
     m_depthStencilState->Release(); 
     m_depthStencilState = 0; 
    } 

    if(m_depthStencilBuffer) 
    { 
     m_depthStencilBuffer->Release(); 
     m_depthStencilBuffer = 0; 
    } 

    if(m_renderTargetView) 
    { 
     m_renderTargetView->Release(); 
     m_renderTargetView = 0; 
    } 

    if(m_deviceContext) 
    { 
     m_deviceContext->Release(); 
     m_deviceContext = 0; 
    } 

    if(m_device) 
    { 
     m_device->Release(); 
     m_device = 0; 
    } 

    if(m_swapChain) 
    { 
     m_swapChain->Release(); 
     m_swapChain = 0; 
    } 

    return; 
} 

void D3DClass::BeginScene(float red, float green, float blue, float alpha) 
{ 
    float color[4]; 

    //setup the color to clear the buffer to. 
    color[0] = red; 
    color[1] = green; 
    color[2] = blue; 
    color[3] = alpha; 

    //Clear the back buffer 
    m_deviceContext->ClearRenderTargetView(m_renderTargetView, color); 

    //Clear the depth buffer 
    m_deviceContext->ClearDepthStencilView(m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0); 

    return; 
} 

void D3DClass::EndScene() 
{ 
    //present the back buffer to the screen since rendering is complete 
    if(m_vsync_enabled) 
    { 
     //Lock to screen refresh rate 
     m_swapChain->Present(1,0); 
    } 
    else 
    { 
     //Present as fast as possible. 
     m_swapChain->Present(0,0); 
    } 

    return; 
} 

ID3D11Device* D3DClass::GetDevice() 
{ 
    return m_device; 
} 

ID3D11DeviceContext* D3DClass::GetDeviceContext() 
{ 
    return m_deviceContext; 
} 

void D3DClass::GetProjectionMatrix(D3DXMATRIX& projectionMatrix) 
{ 
    projectionMatrix = m_projectionMatrix; 
    return; 
} 

void D3DClass::GetWorldMatrix(D3DXMATRIX& worldMatrix) 
{ 
    worldMatrix = m_worldMatrix; 
    return; 
} 

void D3DClass::GetOrthoMatrix(D3DXMATRIX& orthoMatrix) 
{ 
    orthoMatrix = m_orthoMatrix; 
    return; 
} 

void D3DClass::GetVideoCardInfo(char* cardName, int& memory) 
{ 
    strcpy_s(cardName, 128, m_videoCardDescription); 
    memory = m_videoCardMemory; 
    return; 
} 

: 내가 변수 (포인터) graphics.cpp라는 다른 파일에서 선언되는 m_D3D라고합니다. 모든 vars를 0 (NULL)로 초기화하기 위해 D3DClass에서 생성자를 호출하면 오류가 발생합니다.

m_D3D CXX0017 : 오류 : 기호 ""

알려 주시기 바랍니다

를 찾을 수 없습니다 내가이 포인터에 m_D3D의 값을 선택하면 내가 다음과 같은 메시지를 발견했다.

건배

Answer 1

디버그 버전으로 컴파일하려면 IDE에서 실행하십시오. 오류가 발생한 위치가 표시됩니다.

( msvcr90.dll는 릴리스 빌드를 실행하는 날을 말한다). 당신은 lib 디렉토리를 포함하고 비주얼 스튜디오로 제대로 디렉토리를 포함하는 경우

Answer 2

궁금해? rastertek에는 문제가있을 경우를 대비 한 멋진 안내가 있습니다.

희망이 도움이됩니다.