D3DX11 i Visual Studio 2015

[Sauron]

Witam wszystkich!

Jakiś czas temu, zacząłem uczyć się DirectX 11. Doszedłem do momentu, w którym muszę skompilować prosty efekt. Bez względu na to jaka jest zawartość shader'a otrzymuje następujący błąd: [lokalizacja pliku](1,1): error X3000: Illegal character in shader file

Kompiluje efekt za pomocą funkcji D3DX11CompileFromFile i D3DX11CreateEffectFromMemory. Wina (raczej) nie może leżeć po stronie kodu, bo jest żywcem wzięty z książki (Frank Luna). Podejrzewam, że problem leży w mieszaniu Windows SDK i DirectX SDK. Podobno wiele się zmieniło i występują niespójności (d3dx11.h zostało wyłączone z zestawu Windows SDK).

Dołączam kod efektu (autorstwa Franka Luna):

Kod: [Zaznacz]

cbuffer cbPerObject
{
float4x4 gWorldViewProj;
};

struct VertexIn
{
float3 PosL  : POSITION;
    float4 Color : COLOR;
};

struct VertexOut
{
float4 PosH  : SV_POSITION;
    float4 Color : COLOR;
};

VertexOut VS(VertexIn vin)
{
VertexOut vout;

vout.PosH = mul(float4(vin.PosL, 1.0f), gWorldViewProj);

    vout.Color = vin.Color;
   
    return vout;
}

float4 PS(VertexOut pin) : SV_Target
{
    return pin.Color;
}

technique11 ColorTech
{
    pass P0
    {
        SetVertexShader( CompileShader( vs_5_0, VS() ) );
SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_5_0, PS() ) );
    }
}

Korzystam z Windows 7 (x64), Visual Studio 2015 i Windows SDK 8.1

[inż. Avallach]

Masz złe kodowanie pliku. Zmień na UTF-8. Na przykład skopij cały tekst, usuń cały plik. Zrób taki sam plik Notatnikiem (nie przez Visual Studio!) i wklej tekst z powrotem.

Tutaj jest wyjaśnienie: http://stackoverflow.com/questions/25708133/impossible-to-compile-hlsl-shaders-after-updating-to-sharpdx-2-6-2

[Sauron]

Wierz mi, że już wcześniej zmieniałem kodowanie i nic to nie dało (może zmieniałem w złej lokalizacji  ). Teraz pomogło. Niestety pojawił się drugi problem. Może zamiast go opisywać pokażę zrzut – będzie lepiej dla Was i dla mnie.

[Adanos]

Wygląda na problem z kodowaniem. Tu podobny problem: https://xtrothearctic.wordpress.com/tag/gettechniquebyname/ Więc wygląda, że plik twojego efektu ma złe kodowanie i powinno być ANSI, zamiast Unicode.

Poza tym nie podoba mi się to

Kod: [Zaznacz]

L"Fx/color.fx"Dziwnie to wygląda, nie wiem co robi tam "L". To coś nowego w C++ czy DX tak ma?

[inż. Avallach]

@Adanos, przecież dwa posty wyżej napisałem że to problem z kodowaniem, podałem źródło i napisał że pomogło

To "L" to prefix dla literału stringa, chodzi o to żeby znaki były przechowywane jako wchar_t.
Błąd który wyskoczył to błąd nie kompilacji, ale runtime - do tego najprostszy na jaki można trafić
"Naruszenie zasad dostępu podczas odczytywania w lokalizacji 0x00000000" to nic innego jak derefenrencja null pointera. Twoja zmienna 'fx' prawdopodobnie zawiera nulla.

[Sauron]

Szczerze powiedziawszy domyśliłem się Pytanie: dlaczego? Powyżej odwołania do fx są dwa warunki sprawdzające czy nie wystąpił żaden błąd kompilacji efektu. Oba nie pokazują nic złego, więc coś w tej zmiennej powinno być.

[inż. Avallach]

Bez kodu nic nie mogę pomóc. Na tym screenie co dałeś nie widać ani przypisania, ani warunków.

[Sauron]

Widać obie rzeczy

Kod: [Zaznacz]

#include <Windows.h>
#include <d3d11.h>
#include <D3DX11.h>
#include <d3dx11effect.h>
#include <sstream>
#include "GameTimer.h"
#include "MathHelper.h"
#include <d3dcompiler.h>

struct Vertex
{
XMFLOAT3 Position;
XMFLOAT3 Color;
};


namespace Colors
{
XMGLOBALCONST XMVECTORF32 White = { 1.0f, 1.0f, 1.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Black = { 0.0f, 0.0f, 0.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Red = { 1.0f, 0.0f, 0.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Green = { 0.0f, 1.0f, 0.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Blue = { 0.0f, 0.0f, 1.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Yellow = { 1.0f, 1.0f, 0.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Cyan = { 0.0f, 1.0f, 1.0f, 1.0f };
XMGLOBALCONST XMVECTORF32 Magenta = { 1.0f, 0.0f, 1.0f, 1.0f };

XMGLOBALCONST XMVECTORF32 Silver = { 0.75f, 0.75f, 0.75f, 1.0f };
XMGLOBALCONST XMVECTORF32 LightSteelBlue = { 0.69f, 0.77f, 0.87f, 1.0f };
}

HWND windowHandler;
const int width = 900;
const int height = 680;
const LPTSTR wndCaption = L"DirectX";

ID3D11Device* d3dDevice;
ID3D11DeviceContext* d3dContext;
IDXGISwapChain* swapChain;
ID3D11RenderTargetView* renderTargetView;
ID3D11Texture2D* depthStencilBuffer;
ID3D11DepthStencilView* depthStencilView;
D3D11_VIEWPORT d3dViewport;

ID3D11Buffer* vertexBuffer;
ID3D11Buffer* indicesBuffer;
ID3D11RasterizerState* rasterState;
ID3DX11Effect* fx;
ID3DX11EffectTechnique* technique;
ID3DX11EffectMatrixVariable* fxMVPMatrix;
ID3D11InputLayout* inputLayout;

XMFLOAT4X4 mWorld;
XMFLOAT4X4 mView;
XMFLOAT4X4 mProj;

float mTheta;
float mPhi;
float mRadius;

GameTimer gameTimer;

void CalculateFrameStats();
void UpdateScene(float dt);
void Render();

void SetMatrices()
{
XMStoreFloat4x4(&mView, XMMatrixIdentity());

XMVECTOR pos = XMVectorSet(0.0f, 0.0f, -1.0f, 1.0f);
XMVECTOR target = XMVectorZero();
XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
XMMATRIX V = XMMatrixLookAtLH(pos, target, up);
XMStoreFloat4x4(&mView, V);

XMMATRIX P = XMMatrixPerspectiveFovLH(0.25f * MathHelper::Pi, (float)width / height, 1.0f, 1000.f);
XMStoreFloat4x4(&mProj, P);
}
void BuildGeometryBuffers()
{
Vertex vertices[] =
{
{ XMFLOAT3(-1.0f, -1.0f, -1.0f), (const float*)&Colors::White },
{ XMFLOAT3(-1.0f, 1.0f, -1.0f), (const float*)&Colors::Black },
{ XMFLOAT3(1.0f, 1.0f, -1.0f), (const float*)&Colors::Red },
{ XMFLOAT3(1.0f, -1.0f, -1.0f), (const float*)&Colors::Green },
{ XMFLOAT3(-1.0f, -1.0f, 1.0f), (const float*)&Colors::Blue },
{ XMFLOAT3(-1.0f, 1.0f, 1.0f), (const float*)&Colors::Yellow },
{ XMFLOAT3(1.0f, 1.0f, 1.0f), (const float*)&Colors::Cyan },
{ XMFLOAT3(1.0f, -1.0f, 1.0f), (const float*)&Colors::Magenta },
};

D3D11_BUFFER_DESC vbd;
vbd.Usage = D3D11_USAGE_IMMUTABLE;
vbd.ByteWidth = sizeof(Vertex) * 8;
vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbd.CPUAccessFlags = 0;
vbd.MiscFlags = 0;
vbd.StructureByteStride = 0;

D3D11_SUBRESOURCE_DATA vertexInitData;
vertexInitData.pSysMem = vertices;

HRESULT hr = d3dDevice->CreateBuffer(&vbd, &vertexInitData, &vertexBuffer);

if (FAILED(hr))
{
MessageBox(NULL, L"Failed to create vertex buffer!", L"Error!", MB_OK | MB_ICONERROR);
}

UINT indices[24] =
{
0, 1, 2,
0, 2, 3,
0, 3, 4,
0, 4, 5,
0, 5, 6,
0, 6, 7,
0, 7, 8,
0, 8, 1
};

D3D11_BUFFER_DESC ibd;
ibd.Usage = D3D11_USAGE_IMMUTABLE;
ibd.ByteWidth = sizeof(UINT) * 24;
ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
ibd.CPUAccessFlags = 0;
ibd.MiscFlags = 0;
ibd.StructureByteStride = 0;

D3D11_SUBRESOURCE_DATA indicesInitData;
indicesInitData.pSysMem = indices;

hr = d3dDevice->CreateBuffer(&ibd, &indicesInitData, &indicesBuffer);

if (FAILED(hr))
{
MessageBox(NULL, L"Failed to create index buffer!", L"Error!", MB_OK | MB_ICONERROR);
}
}
void BuildFX()
{
DWORD shaderFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
shaderFlags |= D3D10_SHADER_DEBUG;
shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif

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

HRESULT hr = D3DX11CompileFromFile(L"FX/color.fx", 0, 0, 0, "fx_5_0", shaderFlags, 0, 0, &compiledShader, &compilationMsgs, 0);

if (compilationMsgs != 0)
{
MessageBoxA(0, (char*)compilationMsgs->GetBufferPointer(), 0, 0);
compilationMsgs->Release();
}
if (FAILED(hr))
{
MessageBox(0, L"Some error while compiling fx file!", L"Error", MB_OK | MB_ICONERROR);
}

D3DX11CreateEffectFromMemory(compiledShader->GetBufferPointer(), compiledShader->GetBufferSize(), 0, d3dDevice, &fx);
compiledShader->Release();

technique = fx->GetTechniqueByName("ColorTech");
fxMVPMatrix = fx->GetVariableByName("gWorldViewProj")->AsMatrix();
}
void BuildVertexLayout()
{
D3D11_INPUT_ELEMENT_DESC vertexDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};

D3DX11_PASS_DESC passDesc;
technique->GetPassByIndex(0)->GetDesc(&passDesc);
d3dDevice->CreateInputLayout(vertexDesc, 2, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &inputLayout);
}

void Dispose()
{
vertexBuffer->Release();
indicesBuffer->Release();
fx->Release();
inputLayout->Release();
renderTargetView->Release();
depthStencilView->Release();
swapChain->Release();
depthStencilBuffer->Release();

if (d3dContext)
d3dContext->ClearState();

d3dContext->Release();
d3dDevice->Release();
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_MENUCHAR:
return MAKELRESULT(0, MNC_CLOSE);
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}

void CalculateFrameStats()
{
static int frameCnt = 0;
static float timeElapsed = 0.0f;

frameCnt++;

if ((gameTimer.TotalTime() - timeElapsed) >= 1.0f)
{
float fps = (float)frameCnt;
float mspf = 1000.0f / fps;

std::wostringstream outs;
outs.precision(6);
outs << wndCaption << L"    "
<< L"FPS: " << fps << L"    "
<< L"Frame Time: " << mspf << L" (ms)";
SetWindowText(windowHandler, outs.str().c_str());

frameCnt = 0;
timeElapsed += 1.0f;
}
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
gameTimer = GameTimer();

WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(WNDCLASSEX));
wc.cbSize = sizeof(WNDCLASSEX);
wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
wc.hInstance = hInstance;
wc.lpfnWndProc = WndProc;
wc.lpszClassName = L"MainWindow";
wc.style = CS_HREDRAW | CS_VREDRAW;

if (!RegisterClassEx(&wc))
{
MessageBox(NULL, L"Could not register window class!", L"Error", MB_OK | MB_ICONERROR);
return 1;
}
RECT rect = { 0, 0, width, height };
AdjustWindowRectEx(&rect, WS_OVERLAPPEDWINDOW, FALSE, NULL);
windowHandler = CreateWindowEx(NULL, L"MainWindow", wndCaption, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, hInstance, NULL);

if (!windowHandler)
{
MessageBox(NULL, L"Could not create window!", L"Error", MB_OK | MB_ICONERROR);
return 1;
}

ShowWindow(windowHandler, SW_SHOW);
UpdateWindow(windowHandler);

UINT createDeviceFlag = 0;
#if defined(DEBUG) || defined(_DEBUG)
createDeviceFlag |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL d3dFeatureLevel;
HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlag, 0, 0, D3D11_SDK_VERSION, &d3dDevice, &d3dFeatureLevel, &d3dContext);
if (FAILED(hr))
{
MessageBox(NULL, L"Failed to create device!", L"Error!", MB_OK | MB_ICONERROR);
return 1;
}

UINT msaa4xQualityLevel;
d3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &msaa4xQualityLevel);

DXGI_SWAP_CHAIN_DESC scd;
scd.BufferDesc.Width = width;
scd.BufferDesc.Height = height;
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scd.BufferDesc.RefreshRate.Numerator = 60;
scd.BufferDesc.RefreshRate.Denominator = 1;
scd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
scd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
scd.SampleDesc.Count = 4;
scd.SampleDesc.Quality = msaa4xQualityLevel - 1;
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scd.Flags = 0;
scd.Windowed = true;
scd.OutputWindow = windowHandler;
scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scd.BufferCount = 1;

IDXGIDevice* dxgiDevice = 0;
d3dDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice));

IDXGIAdapter* dxgiAdapter = 0;
dxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&dxgiAdapter));

IDXGIFactory* dxgiFactory = 0;
dxgiAdapter->GetParent(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&dxgiFactory));

dxgiFactory->CreateSwapChain(d3dDevice, &scd, &swapChain);

dxgiDevice->Release();
dxgiAdapter->Release();
dxgiFactory->Release();

ID3D11Texture2D* backBuffer;
swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer));
d3dDevice->CreateRenderTargetView(backBuffer, 0, &renderTargetView);
backBuffer->Release();

D3D11_TEXTURE2D_DESC depthStencilDesc;
depthStencilDesc.ArraySize = 1;
depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthStencilDesc.CPUAccessFlags = 0;
depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilDesc.Width = width;
depthStencilDesc.Height = height;
depthStencilDesc.MipLevels = 1;
depthStencilDesc.MiscFlags = 0;
depthStencilDesc.SampleDesc.Count = 4;
depthStencilDesc.SampleDesc.Quality = msaa4xQualityLevel - 1;
depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;

d3dDevice->CreateTexture2D(&depthStencilDesc, 0, &depthStencilBuffer);
d3dDevice->CreateDepthStencilView(depthStencilBuffer, 0, &depthStencilView);

d3dContext->OMSetRenderTargets(1, &renderTargetView, depthStencilView);

d3dViewport.TopLeftX = 100;
d3dViewport.TopLeftY = 100;
d3dViewport.Width = 500;
d3dViewport.Height = 500;
d3dViewport.MinDepth = 0.0;
d3dViewport.MaxDepth = 1.0;

d3dContext->RSSetViewports(1, &d3dViewport);

SetMatrices();

BuildGeometryBuffers();
BuildFX();
BuildVertexLayout();

gameTimer.Reset();

MSG msg = { 0 };
while (msg.message != WM_QUIT)
{
if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
gameTimer.Tick();
CalculateFrameStats();
UpdateScene(gameTimer.DeltaTime());
Render();
}
}

Dispose();

return msg.wParam;
}

void UpdateScene(float dt)
{

}

void Render()
{
d3dContext->ClearRenderTargetView(renderTargetView, reinterpret_cast<const float*>(&Colors::Black));
d3dContext->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0, 0);

d3dContext->IASetInputLayout(inputLayout);
d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex);
UINT offset = 0;
d3dContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
d3dContext->IASetIndexBuffer(indicesBuffer, DXGI_FORMAT_R32_UINT, 0);

XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX view = XMLoadFloat4x4(&mView);
XMMATRIX proj = XMLoadFloat4x4(&mProj);
XMMATRIX mvp = world*view*proj;
fxMVPMatrix->SetMatrix(reinterpret_cast<float*>(&mvp));

D3DX11_TECHNIQUE_DESC techDesc;
technique->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
technique->GetPassByIndex(p)->Apply(0, d3dContext);
d3dContext->DrawIndexed(36, 0, 0);
}

swapChain->Present(0, 0);
}

Ze względu na to, że kodu jest w miarę dużo i nie jest zbyt ładny, zalecam początkowo obadać metodę BuildFX.

[inż. Avallach]

Jedyne co robisz ze zmienną (przechowującą wskaźnik, domyślnie nullptr) fx to podanie wskaźnika na nią do funkcji D3DX11CreateEffectFromMemory, potem od razu ją wykorzystujesz. Popełniasz tu kilka błędów.

Przede wszystkim sprawdź co zwraca ta funkcja która miała ci wstawić poprawny wskaźnik do fx. Będzie to jeden z wyliczonych tutaj kodów: https://msdn.microsoft.com/en-us/library/windows/desktop/ff476174.aspx . Jeśli nie jset to S_OK, nie powinieneś zakładać że fx będzie w jakikolwiek sposób użyteczne.

Po drugie, nie sprawdzasz czy pod fx faktycznie coś podstawiono. Gdybyś sprawdzał chociaż zwracany kod tamtej, można by to olać, ale teraz nie sprawdzasz dosłownie nic i aż prosisz się o ten wyjątek. W prawdziwej aplikacji to niedopuszczalne.

Trzecim problemem jest to że używasz globalnych zmiennych. Można napisać z nimi działający program, ale jego analiza jest znacząco trudniejsza, zwłaszcza jeśli nie ma się dostępu do jego całości. To bardzo zła praktyka.

Kolejnym problemem jest to że chyba nie do końca rozumiesz czym jest przypisanie i warunki sprawdzające czy wskaźnik nie jest nullem:

Bez kodu nic nie mogę pomóc. Na tym screenie co dałeś nie widać ani przypisania, ani warunków.

Widać obie rzeczy

Na screenie którego dałeś widać ten fragment kodu:

Spoiler

Kod: [Zaznacz]

ID3D10Blob* compilationMsgs = 0;

HRESULT hr = D3DX11CompileFromFile(L"FX/color.fx", 0, 0, 0, "fx_5_0", shaderFlags, 0, 0, &compiledShader, &compilationMsgs, 0);

if (compilationMsgs != 0)
{
MessageBoxA(0, (char*)compilationMsgs->GetBufferPointer(), 0, 0);
compilationMsgs->Release();
}
if (FAILED(hr))
{
MessageBox(0, L"Some error while compiling fx file!", L"Error", MB_OK | MB_ICONERROR);
}

D3DX11CreateEffectFromMemory(compiledShader->GetBufferPointer(), compiledShader->GetBufferSize(), 0, d3dDevice, &fx);
compiledShader->Release();

technique = fx->GetTechniqueByName("ColorTech");
fxMVPMatrix = fx->GetVariableByName("gWorldViewProj")->AsMatrix();
}

Nie ma tu ani przypisania do zmiennej fx, ani sprawdzenia jej zawartości. Raz używasz wskaźnika na nią (...Device, &fx);), zaraz potem dokonujesz jej dereferencji (... = fx->Get...).

[Sauron]

Rzeczywiście nie sprawdzałem jej zawartości, myślałem że mówisz o sprawdzeniu wyniku D3DX11CompileFromFile, a przypisanie uznałem za podanie wskaźnika do fx odpowiedniej metodzie (skrót myślowy, czy jakkolwiek to nazwać).

HRESULT po wywołaniu D3DX11CreateEffectFromMemory to E_NOINTERFACE. Z http://stackoverflow.com/questions/12549472/using-directx-effect11-with-visual-studio-2012 wynika, że błąd jest spowodowany wersją DX11, a dokładniej tym, że D3DX jest "deprecated". Najwidoczniej będę musiał użyć czegoś innego.

Nie wiem dlaczego sam nie wpadłem na to, żeby sprawdzić co zwraca to funkcja  . W każdym razie: dziękuję za pomoc!