bool Prism::DirectX::D3DSetup()
{
if (D3DSwapChainSetup() == false)
{
DIRECTX_LOG("Failed to Setup DirectX SwapChain");
return false;
}
if (D3DBackbufferSetup(mySetupInfo.myScreenWidth, mySetupInfo.myScreenHeight) == false)
{
DIRECTX_LOG("Failed to Setup Backbuffer");
return false;
}
if (D3DViewPortSetup(mySetupInfo.myScreenWidth, mySetupInfo.myScreenHeight) == false)
{
DIRECTX_LOG("Failed to Setup DirectX ViewPort");
return false;
}
if (D3DEnabledStencilStateSetup() == false)
{
DIRECTX_LOG("Failed to Setup EnabledStencilBuffer");
return false;
}
if (D3DDisabledStencilStateSetup() == false)
{
DIRECTX_LOG("Failed to Setup DisabledStencilBuffer");
return false;
}
if (D3DWireframeRasterizerStateSetup() == false)
{
DIRECTX_LOG("Failed to Setup WireframeRasterizerState");
return false;
}
if (D3DSolidRasterizerStateSetup() == false)
{
DIRECTX_LOG("Failed to Setup SolidRasterizerState");
return false;
}
if (D3DNoCullingRasterizerStateSetup() == false)
{
DIRECTX_LOG("Failed to Setup SolidRasterizerState");
return false;
}
DisableWireframe();
EnableZBuffer();
DIRECTX_LOG("DirectX Setup Successful");
return true;
}
void StateRenderTest::Render()
{
auto renderInterface = m_appData->renderInterface;
auto keyboard = m_appData->keyboard;
auto mouse = m_appData->mouse;
auto shaderPack = m_appData->shaderPack;
auto debugWorld = m_appData->debugWorld;
shaderPack->UpdateFrameBuffers(renderInterface, m_camera.GetViewMatrix());
//if (!m_haveWrittenToTexture)
//{
// beTexture writeTexture;
// beTexture::LoadOptions textureLoadOptions;
// textureLoadOptions.height = 512;
// textureLoadOptions.width = 512;
// textureLoadOptions.format = beTextureFormat::R32G32B32_FLOAT;
// writeTexture.InitAsTarget(renderInterface, textureLoadOptions);
// defer(
// writeTexture.Deinit();
// );
// m_haveWrittenToTexture = true;
// writeTexture.SetAsTarget(renderInterface);
// writeTexture.Clear(renderInterface, V40());
// m_models[3].Render(renderInterface, shaderPack, beRendering::ShaderType::Colour);
//
// renderInterface->DisableZBuffer();
// shaderPack->shaderTexture2d.SetShaderParameters(renderInterface, m_camera.GetViewMatrix());
//
// //m_bitmapTexQuad.Render(renderInterface);
// //textureShader2d.Render(renderInterface, m_bitmapTexQuad.GetIndexCount(), m_bitmapTexQuad.GetTexture());
//
// renderInterface->EnableAlpha();
// m_bitmapTextDynamic.InitText(renderInterface, &m_font, "initial string", 1.f, 640.f, 0, false, beFont::WrapMode::Default);
// m_bitmapTextDynamic.SetPosition((float)(-writeTexture.GetWidth() / 2), (float)(writeTexture.GetHeight() / 2));
// m_bitmapTextDynamic.Render(renderInterface);
// shaderPack->shaderTexture2d.Render(renderInterface, m_bitmapTextDynamic.GetIndexCount(), m_bitmapTextDynamic.GetTexture(), true);
// renderInterface->DisableAlpha();
// renderInterface->EnableZBuffer();
// renderInterface->RestoreRenderTarget();
// writeTexture.FinaliseTarget();
//
// m_bitmapTextPreRendered.Init(renderInterface, writeTexture);
// m_bitmapTextPreRendered.SetPosition(-400, -400);
//}
auto renderFrame = [&](bool writingToScreenGrabTexture)
{
beModel* modelToRender = m_modelToUse < m_models.Count() ? &m_models[m_modelToUse] : nullptr;
if (modelToRender)
{
modelToRender->Render(renderInterface, shaderPack, m_shaderToUse);
}
if (m_renderGrid)
{
m_gridModel.Render(renderInterface, shaderPack);
}
debugWorld->SetRenderAxes(m_renderAxes);
debugWorld->Render(renderInterface, &shaderPack->shaderColour, m_camera.GetViewMatrix(), m_camera.GetPosition());
renderInterface->DisableZBuffer();
shaderPack->shaderTexture2d.SetShaderParameters(renderInterface, m_camera.GetViewMatrix());
if (m_bitmapScreenGrab.GetTexture() && !writingToScreenGrabTexture)
{
m_bitmapScreenGrab.Render(renderInterface);
shaderPack->shaderTexture2d.Render(renderInterface, m_bitmapScreenGrab.GetIndexCount(), m_bitmapScreenGrab.GetTexture(), true);
}
m_bitmapTexQuadNorm.Render(renderInterface);
shaderPack->shaderTexture2d.Render(renderInterface, m_bitmapTexQuadNorm.GetIndexCount(), m_bitmapTexQuadNorm.GetTexture(), true);
m_bitmapTexQuadPixelCoord.Render(renderInterface);
shaderPack->shaderTexture2d.Render(renderInterface, m_bitmapTexQuadPixelCoord.GetIndexCount(), m_bitmapTexQuadPixelCoord.GetTexture(), false);
renderInterface->EnableAlpha();
{
const Vec3 cameraPos = m_camera.GetPosition();
const Matrix viewMatrix = m_camera.GetViewMatrix();
const float screenX = (float)mouse->GetX();
const float screenY = (float)mouse->GetY();
Vec3 worldPos, worldDir;
const bool isInBounds = beCameraUtils::GetScreeenToWorldRay(*renderInterface, m_camera.GetViewMatrix(), screenX, screenY, &worldPos, &worldDir);
auto maybeRealWorldPos = beCameraUtils::WorldPosFromScreenPos(*renderInterface, m_camera.GetViewMatrix(), (int)screenX, (int)screenY);
if (!isInBounds)
{
worldPos = V3N1();
worldDir = V3N1();
}
if (!maybeRealWorldPos)
{
maybeRealWorldPos = V3N1();
}
fmt::memory_buffer message;
fmt::format_to(message, "Dynamic Text\n");
fmt::format_to(message, "Mouse [X, Y]: [{}, {}]\n", mouse->GetX(), mouse->GetY());
fmt::format_to(message, "Camera [X, Y, Z]: [{:.2f}, {:.2f}, {:.2f}]\n", cameraPos.x, cameraPos.y, cameraPos.z);
fmt::format_to(message, "Mat Right [X, Y, Z, W]: [{:.2f}, {:.2f}, {:.2f}, {:.2f}]\n", viewMatrix.m[0][0], viewMatrix.m[0][1], viewMatrix.m[0][2], viewMatrix.m[0][3]);
fmt::format_to(message, "Mat Up [X, Y, Z, W]: [{:.2f}, {:.2f}, {:.2f}, {:.2f}]\n", viewMatrix.m[1][0], viewMatrix.m[1][1], viewMatrix.m[1][2], viewMatrix.m[1][3]);
fmt::format_to(message, "-Mat Forw [X, Y, Z, W]: [{:.2f}, {:.2f}, {:.2f}, {:.2f}]\n", viewMatrix.m[2][0], viewMatrix.m[2][1], viewMatrix.m[2][2], viewMatrix.m[2][3]);
fmt::format_to(message, "_Mat Pos [X, Y, Z, W]: [{:.2f}, {:.2f}, {:.2f}, {:.2f}]\n", viewMatrix.m[3][0], viewMatrix.m[3][1], viewMatrix.m[3][2], viewMatrix.m[3][3]);
;
if (isInBounds)
{
fmt::format_to(message, "ClickPos [X, Y, Z]: [{:.2f}, {:.2f}, {:.2f}]\n", worldPos.x, worldPos.y, worldPos.z);
fmt::format_to(message, "ClickDir [X, Y, Z]: [{:.2f}, {:.2f}, {:.2f}]\n", worldDir.x, worldDir.y, worldDir.z);
}
if (maybeRealWorldPos)
{
fmt::format_to(message, "Collision [X, Y, Z]: [{:.2f}, {:.2f}, {:.2f}]\n", maybeRealWorldPos->x, maybeRealWorldPos->y, maybeRealWorldPos->z);
}
beString messageStr = fmt::to_string(message);
m_bitmapTextDynamic.InitText(renderInterface, &m_font, messageStr.c_str(), 1.5f, 512.f, 0, false, beFont::WrapMode::Default);
m_bitmapTextDynamic.Render(renderInterface);
shaderPack->shaderTexture2d.Render(renderInterface, m_bitmapTextDynamic.GetIndexCount(), m_bitmapTextDynamic.GetTexture(), false, beShaderTexture2d::TextureMode::Clamped);
}
renderInterface->DisableAlpha();
renderInterface->EnableZBuffer();
};
const bool doScreenGrab = keyboard->IsPressed(beKeyboard::Button::Space);
if (doScreenGrab)
{
m_screenGrabTexture.SetAsTarget(renderInterface);
m_screenGrabTexture.Clear(renderInterface, V40());
renderFrame(true);
renderInterface->RestoreRenderTarget();
m_bitmapScreenGrab.Init(renderInterface, m_screenGrabTexture);
renderInterface->ClearDepth();
}
renderFrame(false);
}
BOOL cGraphics::SetMode(HWND hWnd, BOOL Windowed, BOOL UseZBuffer, long Width, long Height, char BPP)
{
D3DPRESENT_PARAMETERS d3dpp;
D3DFORMAT Format, AltFormat;
RECT WndRect, ClientRect;
long WndWidth, WndHeight;
float Aspect;
// Error checking
if((m_hWnd = hWnd) == NULL)
return FALSE;
if(m_pD3D == NULL)
return FALSE;
// Get the current display format
if(FAILED(m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &m_d3ddm)))
return FALSE;
// Configure width
if(!Width) {
// Default to screen width if fullscreen
if(Windowed == FALSE) {
m_Width = m_d3ddm.Width;
} else {
// Otherwise grab from client size
GetClientRect(m_hWnd, &ClientRect);
m_Width = ClientRect.right;
}
} else {
m_Width = Width;
}
// Configure height
if(!Height) {
// Default to screen height if fullscreen
if(Windowed == FALSE) {
m_Height = m_d3ddm.Height;
} else {
// Otherwise grab from client size
GetClientRect(m_hWnd, &ClientRect);
m_Height = ClientRect.bottom;
}
} else {
m_Height = Height;
}
// Configure BPP
if(!(m_BPP = BPP) || Windowed == TRUE) {
if(!(m_BPP = GetFormatBPP(m_d3ddm.Format)))
return FALSE;
}
// Resize client window if using windowed mode
if(Windowed == TRUE) {
GetWindowRect(m_hWnd, &WndRect);
GetClientRect(m_hWnd, &ClientRect);
WndWidth = (WndRect.right - (ClientRect.right - m_Width)) - WndRect.left;
WndHeight = (WndRect.bottom - (ClientRect.bottom - m_Height)) - WndRect.top;
MoveWindow(m_hWnd, WndRect.left, WndRect.top, WndWidth, WndHeight, TRUE);
}
// Clear presentation structure
ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
// Default to no hardware acceleration detected
m_HAL = FALSE;
// Setup Windowed or fullscreen usage
if((m_Windowed = Windowed) == TRUE) {
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = m_d3ddm.Format;
// See if card supports HAL
if(CheckFormat(m_d3ddm.Format, TRUE, TRUE) == TRUE) {
m_HAL = TRUE;
} else {
// Return error if not emulated
if(CheckFormat(m_d3ddm.Format, TRUE, FALSE) == FALSE)
return FALSE;
}
} else {
d3dpp.Windowed = FALSE;
d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP;
d3dpp.BackBufferWidth = m_Width;
d3dpp.BackBufferHeight = m_Height;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // or D3DPRESENT_INTERVAL_DEFAULT or D3DPRESENT_INTERVAL_IMMEDIATE
// Figure display format to use
if(m_BPP == 32) {
Format = D3DFMT_X8R8G8B8;
AltFormat = D3DFMT_X8R8G8B8;
}
if(m_BPP == 24) {
Format = D3DFMT_R8G8B8;
AltFormat = D3DFMT_R8G8B8;
}
if(m_BPP == 16) {
Format = D3DFMT_R5G6B5;
AltFormat = D3DFMT_X1R5G5B5;
}
if(m_BPP == 8) {
Format = D3DFMT_P8;
AltFormat = D3DFMT_P8;
}
// Check for HAL device
if(CheckFormat(Format, FALSE, TRUE) == TRUE) {
m_HAL = TRUE;
} else {
// Check for HAL device in alternate format
if(CheckFormat(AltFormat, FALSE, TRUE) == TRUE) {
m_HAL = TRUE;
Format = AltFormat;
} else {
// Check for Emulation device
if(CheckFormat(Format, FALSE, FALSE) == FALSE) {
// Check for Emulation device in alternate format
if(CheckFormat(AltFormat, FALSE, FALSE) == FALSE)
return FALSE;
else
Format = AltFormat;
}
}
}
d3dpp.BackBufferFormat = Format;
}
// Setup Zbuffer format - 16 bit
if((m_ZBuffer = UseZBuffer) == TRUE) {
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
} else {
d3dpp.EnableAutoDepthStencil = FALSE;
}
// Create the Direct3D Device object
if(FAILED(m_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
(m_HAL == TRUE) ? D3DDEVTYPE_HAL : D3DDEVTYPE_REF,
hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &m_pD3DDevice))) {
// Try to create Direct3D without ZBuffer support
// if selected and first call failed.
if(m_ZBuffer == TRUE) {
m_ZBuffer = FALSE;
d3dpp.EnableAutoDepthStencil = FALSE;
if(FAILED(m_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
(m_HAL == TRUE) ? D3DDEVTYPE_HAL : D3DDEVTYPE_REF,
hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &m_pD3DDevice)))
return FALSE;
} else
return FALSE;
}
//// create and set the render target surface
// // it should be lockable on XP and nonlockable on Vista
// if (FAILED(m_pD3DDevice->CreateRenderTarget(m_Width, m_Height,
// D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0,
// TRUE, // lockable
// &m_pD3DSurface, NULL)))
// {
// return FALSE;
// }
// //m_pD3DDevice->SetRenderTarget(0, m_pD3DSurface);
// Set default rendering states
EnableLighting(FALSE);
EnableZBuffer(m_ZBuffer);
EnableAlphaBlending(FALSE);
EnableAlphaTesting(FALSE);
// Enable texture rendering stages and filter types
m_pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
m_pD3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
m_pD3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
m_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
m_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
// Set default ambient color to white
SetAmbientLight(255,255,255);
// Calculate the aspect ratio based on window size
Aspect = (float)m_Height / (float)m_Width;
SetPerspective(D3DX_PI/4, Aspect, 1.0f, 10000.0f);
// Create a sprite interface
if(FAILED(D3DXCreateSprite(m_pD3DDevice, &m_pSprite)))
return FALSE;
return TRUE;
}
