Понедельник, 02 Декабря 2024, 10:33

Приветствую Вас Гость

[ Новые сообщения · Игроделы · Правила · Поиск ]
  • Страница 1 из 1
  • 1
Форум игроделов » Записи участника » Напильник [1]
Результаты поиска
НапильникДата: Пятница, 28 Июня 2013, 16:17 | Сообщение # 1 | Тема: Приложение на DirectX 11 не работает. Нужна помощь
уже был
Сообщений: 1
Сейчас нет на сайте
Добрый день. Я бы не стал задавать этот вопрос, поскольку понимаю, что скорее всего, пошлете в отладчик. В отладчике я провел много времени. Функции Visual Studio для отладки 3d графики недоступны, так как даже ничего не рисуется(а чтобы они работали, должен быть хотя бы один треугольник). Итак, суть вопроса. Нужно отрендерить в два окошка, используя Qt 4. В коде нет ничего постороннего, он простой, и его я сейчас выложу. Дефолтная swapchain выводит синий вьюпорт, как положено. Второе окно всегда черное. В чем дело?

Real3dEditor.cpp

#include "real3deditor.h"
#include "SceneManager.h"
#include <QTimer>

Real3DEditor::Real3DEditor(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
ui.setupUi(this);
HWND handle = ui.frameTopViewport->winId();
HWND handle2 = ui.widgetViewport->winId();
mDefaultViewportWidth = 385;
mDefaultViewportHeight = 309;
mSceneManager = new SceneManager();
mSceneManager->InitializeRenderEngine(mDefaultViewportWidth,mDefaultViewportHeight,handle,handle2);
QTimer::singleShot(1000,this,SLOT(RenderOneFrame()));
}
Real3DEditor::~Real3DEditor()
{
}
void Real3DEditor::mouseMoveEvent( QMouseEvent *e )
{
RenderOneFrame();
}
void Real3DEditor::RenderOneFrame()
{
mSceneManager->Render();
}

SceneManager.cpp

#include "SceneManager.h"
#include "DX11RenderEngine.h"
SceneManager::SceneManager(void)
{
}
SceneManager::~SceneManager(void)
{
}
bool SceneManager::Render()
{
return mRenderEngine->RenderScene();
}
bool SceneManager::InitializeRenderEngine( unsigned int width, unsigned int height, HWND handle, HWND handle2 )
{
mRenderEngine = new DX11RenderEngine();
return mRenderEngine->Initialize(width,height,handle,handle2);
}

RenderEngine.cpp

#include "DX11RenderEngine.h"
#include "DX11RenderPersistentData.h"
#include "r3dRenderWindow.h"
DX11RenderEngine::DX11RenderEngine(void)
{
}
DX11RenderEngine::~DX11RenderEngine(void)
{
}
bool DX11RenderEngine::Initialize( unsigned int width, unsigned int height, HWND handle,HWND handle2 )
{
HRESULT hres;
mDirectXVariables = new DX11RenderPersistentData(handle,width,height);
mRenderWindow = new r3dRenderWindow(width,height,handle2);
mRenderWindow->SetDevice(mDirectXVariables->GetDevice());
mRenderWindow->SetDeviceContext(mDirectXVariables->GetDeviceContext());
mRenderWindow->CreateRenderTarget();
mRenderWindow->SetRenderTarget();
backgrondColor = ColorRGBA(1,1,1,1);
return true;
}
bool DX11RenderEngine::RenderScene()
{
mRenderWindow->TestRender(backgrondColor);
return true;
}

PersistentData.cpp

#include "DX11RenderPersistentData.h"
#include "ColorRGBA.h"
DX11RenderPersistentData::DX11RenderPersistentData(void)
{}
DX11RenderPersistentData::DX11RenderPersistentData( HWND defaultHandle, unsigned int defaultWidth, unsigned int defaultHeight )
{
HRESULT ddres;
D3D_FEATURE_LEVEL f_level[] =
{
D3D_FEATURE_LEVEL_11_0
};
DXGI_SWAP_CHAIN_DESC sc_desc;
ZeroMemory(&sc_desc, sizeof(DXGI_SWAP_CHAIN_DESC));
sc_desc.BufferCount = 2;
sc_desc.BufferDesc.Width = defaultWidth;
sc_desc.BufferDesc.Height = defaultHeight;
sc_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sc_desc.BufferDesc.RefreshRate.Numerator = 60;
sc_desc.BufferDesc.RefreshRate.Denominator = 1;
sc_desc.SampleDesc.Count = 1;
sc_desc.SampleDesc.Quality = 0;
sc_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sc_desc.OutputWindow = defaultHandle;
sc_desc.Windowed = true;
sc_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
ddres = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, &f_level[0], 1, D3D11_SDK_VERSION,
&sc_desc, &defaultSwapChain, &mDevice, NULL, &mDeviceContext);

ddres = defaultSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&defaultBackBuffer);
ddres = mDevice->CreateRenderTargetView(defaultBackBuffer, NULL, &mRenderTargetView);
defaultBackBuffer->Release();
}
DX11RenderPersistentData::~DX11RenderPersistentData(void)
{
}
ID3D11Device* DX11RenderPersistentData::GetDevice()
{
return mDevice;
}
ID3D11DeviceContext* DX11RenderPersistentData::GetDeviceContext()
{
return mDeviceContext;
}

RenderWindow.cpp

#include "r3dRenderWindow.h"
#include "DXGI.h"
r3dRenderWindow::r3dRenderWindow(void)
{
mStartVertex = 0;
}
r3dRenderWindow::r3dRenderWindow( unsigned int width, unsigned int height, HWND handle ):
mWidth(width), mHeight(height), mHandle(handle)
{
}
r3dRenderWindow::~r3dRenderWindow(void)
{
}
bool r3dRenderWindow::Draw()
{
return false;
}
bool r3dRenderWindow::TestRender(ColorRGBA color )
{
mDeviceContext->ClearRenderTargetView(mRenderTargetView,color.s);
mDeviceContext->ClearDepthStencilView(mZBufferView,D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL,1.0F,0.0F);
mSwapChain->Present(0,0);

return true;
}
bool r3dRenderWindow::Present()
{
return true;
}
bool r3dRenderWindow::CreateRenderTarget()
{
HRESULT hres;
D3D11_TEXTURE2D_DESC mRTDesc;
ZeroMemory(&mRTDesc,sizeof(D3D11_TEXTURE2D_DESC));
mRTDesc.ArraySize = 1;
mRTDesc.BindFlags = D3D11_BIND_RENDER_TARGET;
mRTDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
mRTDesc.CPUAccessFlags = 0;
mRTDesc.Width = mWidth;
mRTDesc.Height = mHeight;
mRTDesc.MipLevels = 1;
mRTDesc.MiscFlags = 0;
mRTDesc.SampleDesc.Count = 1;
mRTDesc.SampleDesc.Quality = 0;
mRTDesc.Usage = D3D11_USAGE_DEFAULT;

hres = mDevice->CreateTexture2D(&mRTDesc,NULL, &mRenderTarget);
if (FAILED(hres))
{
return false;
}
D3D11_RENDER_TARGET_VIEW_DESC mRTViewDesc;
ZeroMemory(&mRTViewDesc,sizeof(D3D11_RENDER_TARGET_VIEW_DESC));
mRTViewDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
mRTViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
mRTViewDesc.Texture2D.MipSlice = 0;

hres = mDevice->CreateRenderTargetView(mRenderTarget,&mRTViewDesc,&mRenderTargetView);
if (FAILED(hres))
{
return false;
}
D3D11_TEXTURE2D_DESC mZBufferDesc;
ZeroMemory(&mZBufferDesc,sizeof(D3D11_TEXTURE2D_DESC));
mZBufferDesc.ArraySize = 1;
mZBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
mZBufferDesc.CPUAccessFlags = 0;
mZBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
mZBufferDesc.Width = mWidth;
mZBufferDesc.Height = mHeight;
mZBufferDesc.MipLevels = 1;
mZBufferDesc.MiscFlags = 0;
mZBufferDesc.SampleDesc.Count = 1;
mZBufferDesc.SampleDesc.Quality = 0;
mZBufferDesc.Usage = D3D11_USAGE_DEFAULT;
if (FAILED(mDevice->CreateTexture2D(&mZBufferDesc,NULL,&mZBuffer)))
{
return false;
}
D3D11_DEPTH_STENCIL_VIEW_DESC mDSViewDesc;
ZeroMemory(&mDSViewDesc,sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC));
mDSViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
mDSViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
mDSViewDesc.Texture2D.MipSlice = 0;

if (FAILED(mDevice->CreateDepthStencilView(mZBuffer,&mDSViewDesc, &mZBufferView)))
{
return false;
}
IDXGIDevice * pDXGIDevice;
hres = mDevice->QueryInterface(__uuidof(IDXGIDevice), (void **)&pDXGIDevice);
if (FAILED(hres))
{
return false;
}
IDXGIAdapter * pDXGIAdapter;
hres = pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&pDXGIAdapter);
if (FAILED(hres))
{
return false;
}

IDXGIFactory * pIDXGIFactory;
hres = pDXGIAdapter->GetParent(__uuidof(IDXGIFactory), (void **)&pIDXGIFactory);
if (FAILED(hres))
{
return false;
}

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

mSwapChainDesc.BufferDesc.Width = mWidth;
mSwapChainDesc.BufferDesc.Height = mHeight;
mSwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
mSwapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
mSwapChainDesc.BufferDesc.RefreshRate.Denominator = 1;

mSwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
mSwapChainDesc.Flags = 0;
mSwapChainDesc.BufferCount = 2;
mSwapChainDesc.OutputWindow = mHandle;
mSwapChainDesc.SampleDesc.Count = 1;
mSwapChainDesc.SampleDesc.Quality = 0;
mSwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
mSwapChainDesc.Windowed = true;
hres = pIDXGIFactory->CreateSwapChain(mDevice,&mSwapChainDesc,&mSwapChain);
if (FAILED(hres))
{
return false;
}
//pIDXGIFactory->Release();
//pDXGIAdapter->Release();
//pDXGIDevice->Release();
D3D11_VIEWPORT viewport;
viewport.Width = (float)mWidth;
viewport.Height = (float)mHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;

mDeviceContext->RSSetViewports( 1, &viewport);
D3D11_DEPTH_STENCIL_DESC z_buffer_state_desc;
ZeroMemory(&z_buffer_state_desc,sizeof(D3D11_DEPTH_STENCIL_DESC));
z_buffer_state_desc.DepthEnable = true;

z_buffer_state_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
z_buffer_state_desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
z_buffer_state_desc.StencilEnable = true;
z_buffer_state_desc.StencilReadMask = 0xFF;
z_buffer_state_desc.StencilWriteMask = 0xFF;
z_buffer_state_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
z_buffer_state_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
z_buffer_state_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
z_buffer_state_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
z_buffer_state_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
z_buffer_state_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
z_buffer_state_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
z_buffer_state_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
hres = mDevice->CreateDepthStencilState(&z_buffer_state_desc,&mDepthState);

ID3D11RasterizerState * g_pRasterState;

D3D11_RASTERIZER_DESC rasterizerState;
rasterizerState.FillMode = D3D11_FILL_SOLID;
rasterizerState.CullMode = D3D11_CULL_FRONT;
rasterizerState.FrontCounterClockwise = true;
rasterizerState.DepthBias = false;
rasterizerState.DepthBiasClamp = 0;
rasterizerState.SlopeScaledDepthBias = 0;
rasterizerState.DepthClipEnable = true;
rasterizerState.ScissorEnable = true;
rasterizerState.MultisampleEnable = false;
rasterizerState.AntialiasedLineEnable = false;

mDevice->CreateRasterizerState( &rasterizerState, &g_pRasterState );

mDeviceContext->RSSetState(g_pRasterState);

D3D11_RECT rects[1];
rects[0].left = 0;
rects[0].right = 640;
rects[0].top = 0;
rects[0].bottom = 480;
mDeviceContext->RSSetScissorRects( 1, rects );
mDeviceContext->OMSetDepthStencilState(mDepthState,1);

return true;
}
void r3dRenderWindow::SetRenderTarget()
{
mDeviceContext->OMSetRenderTargets(1,&mRenderTargetView,mZBufferView);
}
void r3dRenderWindow::SetDevice( ID3D11Device* device )
{
mDevice = device;
}
void r3dRenderWindow::SetDeviceContext( ID3D11DeviceContext* context )
{
mDeviceContext = context;
}

Вроде бы все показал. Да, это было на Gamedev.ru, но там не ответили, а сам я понять, что случилось, не в состоянии. Жду помощи.

Добавлено (28.06.2013, 16:17)
---------------------------------------------
Для тех, кто будет разбираться в этом коде. Ошибка найдена. Нужно взять backbuffer из созданной swapchain, и потом по нему создать rendertargetview. Создавать сначала текстуру по описанию не нужно. Тема исчерпана.

Сообщение отредактировал Напильник - Пятница, 28 Июня 2013, 15:49
Форум игроделов » Записи участника » Напильник [1]
  • Страница 1 из 1
  • 1
Поиск:

Все права сохранены. GcUp.ru © 2008-2024 Рейтинг