void StateManager9::setDepthFunc(bool depthTest, GLenum depthFunc)
{
if (depthTest)
{
IDirect3DDevice9 *device = mRenderer9->getDevice();
device->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
device->SetRenderState(D3DRS_ZFUNC, gl_d3d9::ConvertComparison(depthFunc));
}
else
{
mRenderer9->getDevice()->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
}
mCurDepthStencilState.depthTest = depthTest;
mCurDepthStencilState.depthFunc = depthFunc;
}
bool GPUContextDX9::initialize()
{
_window = DX9Window::create();
if( _window == NULL )
{
DX9WARN << "Could not create offscreen window.";
return false;
}
HWND windowHandle = _window->getWindowHandle();
_direct3D = Direct3DCreate9( D3D_SDK_VERSION );
if( _direct3D == NULL )
{
DX9WARN << "Could not create Direct3D interface.";
return false;
}
D3DPRESENT_PARAMETERS deviceDesc;
ZeroMemory( &deviceDesc, sizeof(deviceDesc) );
deviceDesc.Windowed = TRUE;
deviceDesc.SwapEffect = D3DSWAPEFFECT_DISCARD;
deviceDesc.BackBufferFormat = D3DFMT_UNKNOWN;
deviceDesc.EnableAutoDepthStencil = FALSE;
deviceDesc.AutoDepthStencilFormat = D3DFMT_D24S8;
HRESULT result = _direct3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, windowHandle,
D3DCREATE_HARDWARE_VERTEXPROCESSING, &deviceDesc, &_device );
if( FAILED(result) )
{
DX9WARN << "Could not create Direct3D device.";
return false;
}
// create vertex buffer
static const int kMaxVertexCount = 64;
result = _device->CreateVertexBuffer(
kMaxVertexCount*sizeof(DX9Vertex), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &_vertexBuffer, NULL );
DX9AssertResult( result, "CreateVertexBuffer failed" );
result = _device->CreateVertexDeclaration( kDX9VertexElements, &_vertexDecl );
DX9AssertResult( result, "CreateVertexDeclaration failed" );
// TIM: set up initial state
result = _device->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
GPUAssert( !FAILED(result), "SetRenderState failed" );
_passthroughVertexShader = createVertexShader( kPassthroughVertexShaderSource );
_passthroughPixelShader = createPixelShader( kPassthroughPixelShaderSource );
for( size_t i = 0; i < kMaximumOutputCount; i++ )
_boundOutputs[i] = NULL;
for( size_t t = 0; t < kMaximumSamplerCount; t++ )
_boundTextures[t] = NULL;
return true;
}
void StateManager9::setStencilOpsBack(GLenum stencilBackFail,
GLenum stencilBackPassDepthFail,
GLenum stencilBackPassDepthPass,
bool frontFaceCCW)
{
IDirect3DDevice9 *device = mRenderer9->getDevice();
device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILFAIL : D3DRS_CCW_STENCILFAIL,
gl_d3d9::ConvertStencilOp(stencilBackFail));
device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILZFAIL : D3DRS_CCW_STENCILZFAIL,
gl_d3d9::ConvertStencilOp(stencilBackPassDepthFail));
device->SetRenderState(!frontFaceCCW ? D3DRS_STENCILPASS : D3DRS_CCW_STENCILPASS,
gl_d3d9::ConvertStencilOp(stencilBackPassDepthPass));
mCurDepthStencilState.stencilBackFail = stencilBackFail;
mCurDepthStencilState.stencilBackPassDepthFail = stencilBackPassDepthFail;
mCurDepthStencilState.stencilBackPassDepthPass = stencilBackPassDepthPass;
}
void StateManager9::setStencilFuncsFront(GLenum stencilFunc,
GLuint stencilMask,
GLint stencilRef,
bool frontFaceCCW,
unsigned int maxStencil)
{
IDirect3DDevice9 *device = mRenderer9->getDevice();
device->SetRenderState(frontFaceCCW ? D3DRS_STENCILFUNC : D3DRS_CCW_STENCILFUNC,
gl_d3d9::ConvertComparison(stencilFunc));
device->SetRenderState(frontFaceCCW ? D3DRS_STENCILREF : D3DRS_CCW_STENCILREF,
(stencilRef < static_cast<int>(maxStencil)) ? stencilRef : maxStencil);
device->SetRenderState(frontFaceCCW ? D3DRS_STENCILMASK : D3DRS_CCW_STENCILMASK, stencilMask);
mCurDepthStencilState.stencilFunc = stencilFunc;
mCurStencilRef = stencilRef;
mCurDepthStencilState.stencilMask = stencilMask;
}
void StateManager9::setBlendFuncsEquations(const gl::BlendState &blendState)
{
if (!blendState.blend)
return;
IDirect3DDevice9 *device = mRenderer9->getDevice();
device->SetRenderState(D3DRS_SRCBLEND, gl_d3d9::ConvertBlendFunc(blendState.sourceBlendRGB));
device->SetRenderState(D3DRS_DESTBLEND, gl_d3d9::ConvertBlendFunc(blendState.destBlendRGB));
device->SetRenderState(D3DRS_BLENDOP, gl_d3d9::ConvertBlendOp(blendState.blendEquationRGB));
if (blendState.sourceBlendRGB != blendState.sourceBlendAlpha ||
blendState.destBlendRGB != blendState.destBlendAlpha ||
blendState.blendEquationRGB != blendState.blendEquationAlpha)
{
device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLENDALPHA,
gl_d3d9::ConvertBlendFunc(blendState.sourceBlendAlpha));
device->SetRenderState(D3DRS_DESTBLENDALPHA,
gl_d3d9::ConvertBlendFunc(blendState.destBlendAlpha));
device->SetRenderState(D3DRS_BLENDOPALPHA,
gl_d3d9::ConvertBlendOp(blendState.blendEquationAlpha));
}
else
{
device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
}
mCurBlendState.sourceBlendRGB = blendState.sourceBlendRGB;
mCurBlendState.destBlendRGB = blendState.destBlendRGB;
mCurBlendState.blendEquationRGB = blendState.blendEquationRGB;
mCurBlendState.blendEquationAlpha = blendState.blendEquationAlpha;
}
static void SetUpLights(){
IDirect3DDevice9 *pDevice = _pGraphics->GetD3DDevice();
D3DXVECTOR3 dir(1.0f, -1.0f, 1.0f);
D3DXCOLOR col(1.0f, 1.0f, 1.0f, 1.0f);
D3DLIGHT9 light;
light.Type = D3DLIGHT_DIRECTIONAL;
light.Ambient = col * 0.4f;
light.Diffuse = col;
light.Specular = col * 0.6f;
light.Direction = dir;
pDevice->SetLight(0, &light);
pDevice->LightEnable(0, true);
//pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE );
pDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
//pDevice->SetRenderState(D3DRS_AMBIENT, 0xFFFFFFFF);
pDevice->SetRenderState(D3DRS_NORMALIZENORMALS, true);
pDevice->SetRenderState(D3DRS_SPECULARENABLE, true);
}
// TODO(dianx) one bit for color mask
void StateManager9::setColorMask(const gl::Framebuffer *framebuffer,
bool red,
bool blue,
bool green,
bool alpha)
{
// Set the color mask
bool zeroColorMaskAllowed = mRenderer9->getVendorId() != VENDOR_ID_AMD;
// Apparently some ATI cards have a bug where a draw with a zero color
// write mask can cause later draws to have incorrect results. Instead,
// set a nonzero color write mask but modify the blend state so that no
// drawing is done.
// http://code.google.com/p/angleproject/issues/detail?id=169
const gl::FramebufferAttachment *attachment = framebuffer->getFirstColorbuffer();
GLenum internalFormat = attachment ? attachment->getInternalFormat() : GL_NONE;
const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
DWORD colorMask = gl_d3d9::ConvertColorMask(
formatInfo.redBits > 0 && red, formatInfo.greenBits > 0 && green,
formatInfo.blueBits > 0 && blue, formatInfo.alphaBits > 0 && alpha);
if (colorMask == 0 && !zeroColorMaskAllowed)
{
IDirect3DDevice9 *device = mRenderer9->getDevice();
// Enable green channel, but set blending so nothing will be drawn.
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_GREEN);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
}
else
{
mRenderer9->getDevice()->SetRenderState(D3DRS_COLORWRITEENABLE, colorMask);
}
mCurBlendState.colorMaskRed = red;
mCurBlendState.colorMaskGreen = green;
mCurBlendState.colorMaskBlue = blue;
mCurBlendState.colorMaskAlpha = alpha;
}
void StateManager9::setStencilOpsFront(GLenum stencilFail,
GLenum stencilPassDepthFail,
GLenum stencilPassDepthPass,
bool frontFaceCCW)
{
// TODO(dianx) It may be slightly more efficient todo these and other similar areas
// with separate dirty bits.
IDirect3DDevice9 *device = mRenderer9->getDevice();
device->SetRenderState(frontFaceCCW ? D3DRS_STENCILFAIL : D3DRS_CCW_STENCILFAIL,
gl_d3d9::ConvertStencilOp(stencilFail));
device->SetRenderState(frontFaceCCW ? D3DRS_STENCILZFAIL : D3DRS_CCW_STENCILZFAIL,
gl_d3d9::ConvertStencilOp(stencilPassDepthFail));
device->SetRenderState(frontFaceCCW ? D3DRS_STENCILPASS : D3DRS_CCW_STENCILPASS,
gl_d3d9::ConvertStencilOp(stencilPassDepthPass));
mCurDepthStencilState.stencilFail = stencilFail;
mCurDepthStencilState.stencilPassDepthFail = stencilPassDepthFail;
mCurDepthStencilState.stencilPassDepthPass = stencilPassDepthPass;
}
HRESULT APPLICATION::Render()
{
// Clear the viewport
m_pDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0L );
// Begin the scene
if(SUCCEEDED(m_pDevice->BeginScene()))
{
//Set camera
D3DXMATRIX view, proj;
D3DXMatrixLookAtLH(&view, &D3DXVECTOR3(0.0f, 10.0f, -50.0f), &D3DXVECTOR3(0.0f, 3.0f, 0.0f), &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
D3DXMatrixOrthoLH(&proj, 10.0f, 9.0f, 0.1f, 1000.0f);
m_pDevice->SetTransform(D3DTS_VIEW, &view);
m_pDevice->SetTransform(D3DTS_PROJECTION, &proj);
if(m_wireframe)m_pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
else m_pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
m_farmer1.Render();
m_farmer2.RenderProgressive();
//Number of polygons
char number[50];
std::string text = itoa(m_farmer2.GetNumProgressiveFaces(), number, 10);
text += " polygons (UP/DOWN Arrow)";
RECT r[] = {{170, 520, 0, 0}, {530, 520, 0, 0}, {470, 540, 0, 0}, {130, 540, 0, 0}};
m_pFont->DrawText(NULL, "Original", -1, &r[0], DT_LEFT| DT_TOP | DT_NOCLIP, 0xff000000);
m_pFont->DrawText(NULL, "Progressive Mesh", -1, &r[1], DT_LEFT| DT_TOP | DT_NOCLIP, 0xff000000);
m_pFont->DrawText(NULL, text.c_str(), -1, &r[2], DT_LEFT| DT_TOP | DT_NOCLIP, 0xff000000);
m_pFont->DrawText(NULL, "(W)ireframe On/Off", -1, &r[3], DT_LEFT| DT_TOP | DT_NOCLIP, 0xff000000);
// End the scene.
m_pDevice->EndScene();
m_pDevice->Present(0, 0, 0, 0);
}
return S_OK;
}
void CubeMesh::DrawRay(const D3DXVECTOR2& screenPos,
const D3DXMATRIX& matWorld, const D3DXMATRIX& matView, const D3DXMATRIX& matProj)
{
HRESULT hr = S_FALSE;
GraphicsDevice* pGDevice = GraphicsDevice::getInstance();
IDirect3DDevice9* pDevice = pGDevice->m_pD3DDevice;
Ray ray = CalcPickingRay((int)screenPos.x, (int)screenPos.y,
pGDevice->mCubeViewport, matView, matProj );
PCVertex rayLine[] = {
{D3DXVECTOR3(0.0f,0.0f,0.0f), D3DCOLOR_ARGB(255,255,0,0)},
{ray.Origin + 1000*ray.Direction, D3DCOLOR_ARGB(255,255,0,0)},
};
PCVertex intersectPoint[] = {
{p, D3DCOLOR_ARGB(255,0,0,255)},
{p+D3DXVECTOR3(0.5f,0.0f,0.0f), D3DCOLOR_ARGB(255,0,0,255)},
{p+D3DXVECTOR3(0.0f,0.5f,0.0f), D3DCOLOR_ARGB(255,0,0,255)},
{p+D3DXVECTOR3(0.0f,0.0f,0.5f), D3DCOLOR_ARGB(255,0,0,255)},
{p+D3DXVECTOR3(-0.5f,0.0f,0.0f), D3DCOLOR_ARGB(255,0,0,255)},
{p+D3DXVECTOR3(0.0f,-0.5f,0.0f), D3DCOLOR_ARGB(255,0,0,255)},
{p+D3DXVECTOR3(0.0f,0.0f,-0.5f), D3DCOLOR_ARGB(255,0,0,255)},
};
pGDevice->SetViewport(pGDevice->mCubeViewport);
pDevice->SetVertexShader(NULL);
pDevice->SetPixelShader(NULL);
V(pDevice->SetTransform(D3DTS_WORLD, &matWorld));
V(pDevice->SetTransform(D3DTS_VIEW, &matView));
V(pDevice->SetTransform(D3DTS_PROJECTION, &matProj));
V(pDevice->SetRenderState(D3DRS_LIGHTING, FALSE));
V(pDevice->SetRenderState(D3DRS_ZENABLE, FALSE));
V(pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE));
V(pDevice->DrawPrimitiveUP(D3DPT_LINELIST, 1, rayLine, sizeof(PCVertex)));
V(pDevice->DrawPrimitiveUP(D3DPT_POINTLIST, 7, intersectPoint, sizeof(PCVertex)));
V(pDevice->SetFVF(NULL));
V(pDevice->SetRenderState(D3DRS_ZENABLE, TRUE));
V(pDevice->SetRenderState(D3DRS_LIGHTING, TRUE));
pGDevice->ResetViewport();
}
//Function to check if the renderer is Direct 3D (If not, it's OpenGL)
bool GameDebugger::IsD3D(ALLEGRO_DISPLAY* mydisplay)
{
IDirect3DDevice9 * whatisthis = al_get_d3d_device(mydisplay);
if(!whatisthis)
return false;
HRESULT isDirect3D = NULL;
isDirect3D = whatisthis->SetRenderState(D3DRS_LIGHTING,false);
if(isDirect3D == D3D_OK)
return true;
return false;
}
void Blit::setCommonBlitState()
{
IDirect3DDevice9 *device = getDevice();
device->SetDepthStencilSurface(NULL);
device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED);
device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, FALSE);
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
RECT scissorRect = {0}; // Scissoring is disabled for flipping, but we need this to capture and restore the old rectangle
device->SetScissorRect(&scissorRect);
}
void UIRender::InitRenderEffect()
{
IDirect3DDevice9* pIDevice = UIDXInit::GetSingleton()->_pIDevice;
// 关闭灯光
pIDevice->SetRenderState( D3DRS_LIGHTING, false );
// 开启颜色alpha透明
pIDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, true );
pIDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
pIDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
// 高斯光栅 会产生颜色渐变效果
pIDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
// 不采用反面拣选
pIDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
// 确定可视柱体
// 设置摄像头位置
UICamera::GetSingleton()->SetCameraView();
// 设置剪裁面宽高比、摄像头上下视角、前后剪裁面与摄像头距离
UICamera::GetSingleton()->SetPerspective( (float)( UIDXInit::GetSingleton()->GetPresentWidth() )/UIDXInit::GetSingleton()->GetPresentHeight() );
}
bool CScreen::SetDefaultGraphicsSettings3D()
{
HRESULT hr;
D3DXMATRIX identityTransform, projTransform;
D3DXMatrixIdentity(&identityTransform);
D3DXMatrixPerspectiveFovLH(&projTransform, D3DX_PI / 4, 1.0f, 1.0f, 100.0f);
D3DXVECTOR3 vEyePt(-10.0f, -10.0f, 10.0f);
D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vUpVec(0.0f, 0.0f, 1.0f);
D3DXMATRIXA16 matView;
D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
D3DCOLORVALUE lightColor = {1.0f, 1.0f, 1.0f, 1.0f};
D3DXVECTOR3 lightDir(-1.0f, 0.7f, -0.2f);
D3DLIGHT9 light;
setupDirectionalLight(light, lightColor, lightDir);
D3DMATERIAL9 mtrl;
ZeroMemory( &mtrl, sizeof( D3DMATERIAL9 ) );
mtrl.Diffuse = lightColor;
mtrl.Ambient = lightColor;
mtrl.Ambient.g = 0.0f;
CGraphicsManager *pGraphicsManager = CGraphicsManager::GetInstance();
IDirect3DDevice9 *pDevice = pGraphicsManager->GetDevice();
CCamera * pCamera = CCamera::GetInstance();
hr = pDevice->SetTransform(D3DTS_WORLD, &identityTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set world transform", hr);
return false;
}
D3DXMATRIX camViewMat = pCamera->GetViewMatrix();
hr = pDevice->SetTransform(D3DTS_VIEW, &camViewMat);
if(FAILED(hr))
{
LogErrorHr("Failed to set view transform", hr);
return false;
}
D3DXMATRIX camProjMat = pCamera->GetProjectionMatrix();
hr = pDevice->SetTransform(D3DTS_PROJECTION, &camProjMat);
if(FAILED(hr))
{
LogErrorHr("Failed to set projection transform", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
if(FAILED(hr))
{
LogErrorHr("Failed to set cull mode render state", hr);
return false;
}
hr = pDevice->SetLight(0, &light);
if(FAILED(hr))
{
LogErrorHr("Failed to set light 0", hr);
return false;
}
hr = pDevice->SetMaterial(&mtrl);
if(FAILED(hr))
{
LogErrorHr("Failed to set material", hr);
return false;
}
hr = pDevice->LightEnable(0, TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to enable light", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_AMBIENT, 0x00202020);
if(FAILED(hr))
{
LogErrorHr("Failed to set ambient color", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to enable z", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ZWRITEENABLE , TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to set z write enabled", hr);
return false;
}
hr = pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
if(FAILED(hr))
{
LogErrorHr("Failed to set sampler state - MINFILTER", hr);
return false;
}
hr = pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
if(FAILED(hr))
{
LogErrorHr("Failed to set sampler state - MAGFILTER", hr);
return false;
}
hr = pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
if(FAILED(hr))
{
LogErrorHr("Failed to set sampler state - MIPFILTER", hr);
return false;
}
return true;
}
void CState::Restore()
{
// viewport
m_D3DDev->SetViewport(&m_Vp);
// render states
m_D3DDev->SetRenderState(D3DRS_ZENABLE, m_Z);
m_D3DDev->SetRenderState(D3DRS_CULLMODE, m_CullMode);
m_D3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, m_AlphaTest);
m_D3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, m_AlphaBlend);
m_D3DDev->SetRenderState(D3DRS_BLENDOP, m_BlendOp);
m_D3DDev->SetRenderState(D3DRS_SRCBLEND, m_SrcBlend);
m_D3DDev->SetRenderState(D3DRS_DESTBLEND, m_DstBlend);
m_D3DDev->SetRenderState(D3DRS_CLIPPLANEENABLE, m_ClipPlane);
m_D3DDev->SetRenderState(D3DRS_FILLMODE, m_FillMode);
m_D3DDev->SetRenderState(D3DRS_LASTPIXEL, m_LastPixel);
m_D3DDev->SetRenderState(D3DRS_FOGENABLE, m_Fog);
m_D3DDev->SetRenderState(D3DRS_STENCILENABLE, m_Stencil);
m_D3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, m_ColorWrite);
m_D3DDev->SetRenderState(D3DRS_SCISSORTESTENABLE, m_Scissor);
if( m_Caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND )
m_D3DDev->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, m_SeparateAlphaBlend);
//if( m_Caps.LineCaps & D3DLINECAPS_ANTIALIAS )
m_D3DDev->SetRenderState(D3DRS_ANTIALIASEDLINEENABLE, m_AntiAliasedLine);
// primitive
m_D3DDev->SetFVF(m_FVF);
m_D3DDev->SetStreamSource(0, m_StreamData, m_StreamOffset, m_StreamStride);
if( m_StreamData )
m_StreamData->Release();
m_D3DDev->SetVertexShader(m_VertexShader);
if( m_VertexShader )
m_VertexShader->Release();
// texture
m_D3DDev->SetTexture(0, m_Tex);
if( m_Tex )
m_Tex->Release();
m_D3DDev->SetPixelShader(m_PixelShader);
if( m_PixelShader )
m_PixelShader->Release();
// texture stage states
m_D3DDev->SetTextureStageState(0, D3DTSS_COLOROP, m_ColorOp);
m_D3DDev->SetTextureStageState(0, D3DTSS_COLORARG1, m_ColorArg1);
m_D3DDev->SetTextureStageState(0, D3DTSS_COLORARG2, m_ColorArg2);
m_D3DDev->SetTextureStageState(0, D3DTSS_ALPHAOP, m_AlphaOp);
m_D3DDev->SetTextureStageState(0, D3DTSS_ALPHAARG1, m_AlphaArg1);
m_D3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, m_TexCoordIndex);
m_D3DDev->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, m_TexTransfFlags);
m_D3DDev->SetSamplerState(0, D3DSAMP_ADDRESSU, m_AddressU);
m_D3DDev->SetSamplerState(0, D3DSAMP_ADDRESSV, m_AddressV);
m_D3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, m_MagFilter);
m_D3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, m_MinFilter);
m_D3DDev->SetSamplerState(0, D3DSAMP_MIPFILTER, m_MipFilter);
}
bool CScreen::SetDefaultGraphicsSettings2D()
{
HRESULT hr;
CGraphicsManager *pGraphicsManager = CGraphicsManager::GetInstance();
IDirect3DDevice9 *pDevice = pGraphicsManager->GetDevice();
D3DXMATRIX identityTransform, projTransform;
D3DXMatrixIdentity(&identityTransform);
D3DXMatrixOrthoLH(&projTransform, 100.0f * pGraphicsManager->GetAspectRatio(), 100.0f, -1.0f, 1.0f);
hr = pDevice->SetTransform(D3DTS_WORLD, &identityTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set world transform", hr);
return false;
}
hr = pDevice->SetTransform(D3DTS_VIEW, &identityTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set view transform", hr);
return false;
}
hr = pDevice->SetTransform(D3DTS_PROJECTION, &projTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set projection transform", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
if(FAILED(hr))
{
LogErrorHr("Failed to set cull mode render state", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to enable z", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to set z write enabled", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
if(FAILED(hr))
{
LogErrorHr("Failed to set lighting to false", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to set alpha blending to true", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
if(FAILED(hr))
{
LogErrorHr("Failed to set alpha source render state", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
if(FAILED(hr))
{
LogErrorHr("Failed to set alpha dest render state", hr);
return false;
}
return true;
}
int __stdcall WinMain(HINSTANCE, HINSTANCE, LPSTR, int){
Application app("Okienko");
// Inicjalizacja Direct3D
IDirect3D9* d3d = Direct3DCreate9(D3D_SDK_VERSION);
// Parametry urzadzenia
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = true;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferCount = 1;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp.BackBufferHeight = app.get_height();
d3dpp.BackBufferWidth = app.get_width();
d3dpp.EnableAutoDepthStencil = true;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
// Tworzenie urzadzenia
IDirect3DDevice9* dev;
d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, app.window_handle(),
D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &dev);
app.init_font(dev, "Courier New");
dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); // Brak obcinania scian
dev->SetRenderState(D3DRS_LIGHTING, false); // Brak swiatla
// Inicjalizacja kamery
// D3DXVECTOR3 eye(0, 5, -10);
D3DXVECTOR3 target(0, 0, 0);
D3DXVECTOR3 up(0, 1, 0);
D3DXMATRIXA16 view;
D3DXMATRIX mProjection;
D3DXMatrixPerspectiveFovLH(&mProjection, D3DX_PI * 0.5f, app.get_width()/(float)app.get_height(), 1, 50);
dev->SetTransform(D3DTS_PROJECTION, &mProjection);
// Model pudelka
Vertex box[] = {
// X Y Z Color
{ 1, 1, 1, D3DCOLOR_XRGB(255, 255, 255)},
{-1, 1, 1, D3DCOLOR_XRGB(0, 255, 255)},
{-1, 1, -1, D3DCOLOR_XRGB(0, 255, 0)},
{ 1, 1, -1, D3DCOLOR_XRGB(255, 255, 0)},
{ 1, -1, 1, D3DCOLOR_XRGB(255, 0, 255)},
{-1, -1, 1, D3DCOLOR_XRGB(0, 0, 255)},
{-1, -1, -1, D3DCOLOR_XRGB(0, 0, 0)},
{ 1, -1, -1, D3DCOLOR_XRGB(255, 0, 0)},
box[0], box[4], box[1], box[5], box[2], box[6], box[3], box[7], box[0], box[4]
};
int box_size = (16 + 2) * sizeof(Vertex);
// Tworzenie bufora wierzcholkow
IDirect3DVertexBuffer9* box_buffer;
dev->CreateVertexBuffer(box_size, 0, Vertex_Format, D3DPOOL_MANAGED, &box_buffer, NULL);
VOID* pVoid;
box_buffer->Lock(0, box_size, (void**)&pVoid, 0);
memcpy(pVoid, box, box_size);
box_buffer->Unlock();
dev->SetFVF(Vertex_Format);
dev->SetStreamSource(0, box_buffer, 0, sizeof(Vertex));
float radius = 3;
while(app.running()){
float alfa = app.get_alfa();
float beta = app.get_beta();
// Aktualizujemy kamere
D3DXVECTOR3 eye(
radius * cos(alfa) * sin(beta),
radius * cos(beta),
radius * sin(alfa) * sin(beta)
);
D3DXMatrixLookAtLH(&view, &eye, &target, &up);
dev->SetTransform(D3DTS_VIEW, &view);
// Rysujemy pudeleczko
dev->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
dev->BeginScene();
for(int i = 0; i < 2; i++) dev->DrawPrimitive(D3DPT_TRIANGLEFAN, i*4, 2);
dev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 8, 8);
app.print(10, 10, "Mysz X = %d", app.get_mouse_x());
app.print(10, 24, "Mysz Y = %d", app.get_mouse_y());
dev->EndScene();
dev->Present(NULL, NULL, NULL, NULL);
}
// Zwalniamy zasoby
box_buffer->Release();
dev->Release();
d3d->Release();
return 0;
}
void DevState::createCleanState() {
if (dwMyThread != 0) {
ods("D3D9: CreateCleanState from other thread.");
}
Stash<DWORD> stashThread(&dwMyThread, GetCurrentThreadId());
if (pSB)
pSB->Release();
pSB = NULL;
IDirect3DStateBlock9* pStateBlock = NULL;
dev->CreateStateBlock(D3DSBT_ALL, &pStateBlock);
if (! pStateBlock)
return;
pStateBlock->Capture();
dev->CreateStateBlock(D3DSBT_ALL, &pSB);
if (! pSB) {
pStateBlock->Release();
return;
}
D3DVIEWPORT9 vp;
dev->GetViewport(&vp);
dev->SetVertexShader(NULL);
dev->SetPixelShader(NULL);
dev->SetFVF(D3DFVF_TLVERTEX);
dev->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
dev->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); // 0x16
dev->SetRenderState(D3DRS_WRAP0, FALSE); // 0x80
dev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
dev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
dev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
dev->SetRenderState(D3DRS_ZENABLE, FALSE);
dev->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
dev->SetRenderState(D3DRS_COLORVERTEX, FALSE);
dev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
dev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
dev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
dev->SetRenderState(D3DRS_LIGHTING, FALSE);
pSB->Capture();
pStateBlock->Apply();
pStateBlock->Release();
}
// parameters should be validated/clamped by caller
EGLint SwapChain9::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
{
if (!mSwapChain)
{
return EGL_SUCCESS;
}
IDirect3DDevice9 *device = mRenderer->getDevice();
// Disable all pipeline operations
device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED);
device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
device->SetPixelShader(NULL);
device->SetVertexShader(NULL);
device->SetRenderTarget(0, mBackBuffer);
device->SetDepthStencilSurface(NULL);
device->SetTexture(0, mOffscreenTexture);
device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
device->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
device->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
D3DVIEWPORT9 viewport = {0, 0, mWidth, mHeight, 0.0f, 1.0f};
device->SetViewport(&viewport);
float x1 = x - 0.5f;
float y1 = (mHeight - y - height) - 0.5f;
float x2 = (x + width) - 0.5f;
float y2 = (mHeight - y) - 0.5f;
float u1 = x / float(mWidth);
float v1 = y / float(mHeight);
float u2 = (x + width) / float(mWidth);
float v2 = (y + height) / float(mHeight);
float quad[4][6] = {{x1, y1, 0.0f, 1.0f, u1, v2},
{x2, y1, 0.0f, 1.0f, u2, v2},
{x2, y2, 0.0f, 1.0f, u2, v1},
{x1, y2, 0.0f, 1.0f, u1, v1}}; // x, y, z, rhw, u, v
mRenderer->startScene();
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, quad, 6 * sizeof(float));
mRenderer->endScene();
device->SetTexture(0, NULL);
RECT rect =
{
x, mHeight - y - height,
x + width, mHeight - y
};
HRESULT result = mSwapChain->Present(&rect, &rect, NULL, NULL, 0);
mRenderer->markAllStateDirty();
if (d3d9::isDeviceLostError(result))
{
return EGL_CONTEXT_LOST;
}
if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DRIVERINTERNALERROR)
{
return EGL_BAD_ALLOC;
}
ASSERT(SUCCEEDED(result));
return EGL_SUCCESS;
}
HRESULT _stdcall MGEProxyD3D::CreateDevice(UINT a, D3DDEVTYPE b, HWND c, DWORD d, D3DPRESENT_PARAMETERS8 *e, IDirect3DDevice8 **f)
{
LOG::logline(">> D3D Proxy CreateDevice");
if(e->Windowed)
{
HWND hMainWnd = GetParent(c);
int wx = std::max(0, (GetSystemMetrics(SM_CXSCREEN) - (int)e->BackBufferWidth) / 2);
int wy = std::max(0, (GetSystemMetrics(SM_CYSCREEN) - (int)e->BackBufferHeight) / 2);
if(Configuration.Borderless)
{
// Remove non-client window parts and move window flush to screen edge / centre if smaller than display
SetWindowLong(hMainWnd, GWL_STYLE, WS_VISIBLE);
SetWindowPos(hMainWnd, NULL, wx, wy, e->BackBufferWidth, e->BackBufferHeight, SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOZORDER);
}
else
{
// Move window to top, with client area centred on one axis
RECT rect = { wx, wy, e->BackBufferWidth, e->BackBufferHeight };
AdjustWindowRect(&rect, GetWindowLong(hMainWnd, GWL_STYLE), FALSE);
SetWindowPos(hMainWnd, NULL, rect.left, 0, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOZORDER);
}
}
// Map 16x antialiasing to equivalent CSAA
D3DMULTISAMPLE_TYPE msaaSamples = (Configuration.AALevel == 16) ? D3DMULTISAMPLE_8_SAMPLES : (D3DMULTISAMPLE_TYPE)Configuration.AALevel;
DWORD msaaQuality = (Configuration.AALevel == 16) ? 2 : 0;
// Override device parameters
// Note that Morrowind will look at the modified parameters
if(e->Flags & D3DPRESENTFLAG_LOCKABLE_BACKBUFFER)
e->Flags ^= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
e->MultiSampleType = msaaSamples;
e->AutoDepthStencilFormat = (D3DFORMAT)Configuration.ZBufFormat;
e->FullScreen_RefreshRateInHz = (!e->Windowed) ? Configuration.RefreshRate : 0;
e->FullScreen_PresentationInterval = (Configuration.VWait == 255) ? D3DPRESENT_INTERVAL_IMMEDIATE : Configuration.VWait;
// Convert presentation parameters to DX9
D3DPRESENT_PARAMETERS9 pp;
pp.BackBufferWidth = e->BackBufferWidth;
pp.BackBufferHeight = e->BackBufferHeight;
pp.BackBufferFormat = e->BackBufferFormat;
pp.BackBufferCount = e->BackBufferCount;
pp.MultiSampleType = e->MultiSampleType;
pp.MultiSampleQuality = msaaQuality;
pp.SwapEffect = e->SwapEffect;
pp.hDeviceWindow = e->hDeviceWindow;
pp.Windowed = e->Windowed;
pp.Flags = e->Flags;
pp.EnableAutoDepthStencil = e->EnableAutoDepthStencil;
pp.AutoDepthStencilFormat = e->AutoDepthStencilFormat;
pp.FullScreen_RefreshRateInHz = e->FullScreen_RefreshRateInHz;
pp.PresentationInterval = e->FullScreen_PresentationInterval;
// Create device in the same manner as the proxy
IDirect3DDevice9 *realDevice = NULL;
HRESULT hr = realD3D->CreateDevice(a, b, c, d, &pp, &realDevice);
if(hr != D3D_OK)
{
LOG::logline("!! D3D Proxy CreateDevice failure");
return hr;
}
*f = factoryProxyDevice(realDevice);
// Set up default render states
Configuration.ScaleFilter = (Configuration.AnisoLevel > 0) ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR;
Configuration.MipFilter = D3DTEXF_LINEAR;
for(int i = 0; i != 4; ++i)
{
realDevice->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, Configuration.AnisoLevel);
realDevice->SetSamplerState(i, D3DSAMP_MINFILTER, Configuration.ScaleFilter);
realDevice->SetSamplerState(i, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&Configuration.LODBias);
}
// Set variables dependent on configuration
DWORD FogPixelMode, FogVertexMode, RangedFog;
if(Configuration.FogMode == 2)
{
FogVertexMode = D3DFOG_LINEAR;
FogPixelMode = D3DFOG_NONE;
RangedFog = 1;
}
else if(Configuration.FogMode == 1)
{
FogVertexMode = D3DFOG_LINEAR;
FogPixelMode = D3DFOG_NONE;
RangedFog = 0;
}
else
{
FogVertexMode = D3DFOG_NONE;
FogPixelMode = D3DFOG_LINEAR;
RangedFog = 0;
}
realDevice->SetRenderState(D3DRS_FOGVERTEXMODE, FogVertexMode);
realDevice->SetRenderState(D3DRS_FOGTABLEMODE, FogPixelMode);
realDevice->SetRenderState(D3DRS_RANGEFOGENABLE, RangedFog);
realDevice->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, (Configuration.AALevel > 0));
LOG::logline("<< D3D Proxy CreateDevice");
return D3D_OK;
}
// parameters should be validated/clamped by caller
EGLint SwapChain9::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
{
if (!mSwapChain)
{
return EGL_SUCCESS;
}
IDirect3DDevice9 *device = mRenderer->getDevice();
// Disable all pipeline operations
device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED);
device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
device->SetPixelShader(NULL);
device->SetVertexShader(NULL);
device->SetRenderTarget(0, mBackBuffer);
device->SetDepthStencilSurface(NULL);
device->SetTexture(0, mOffscreenTexture);
device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
device->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
device->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
for (UINT streamIndex = 0; streamIndex < gl::MAX_VERTEX_ATTRIBS; streamIndex++)
{
device->SetStreamSourceFreq(streamIndex, 1);
}
D3DVIEWPORT9 viewport = {0, 0, mWidth, mHeight, 0.0f, 1.0f};
device->SetViewport(&viewport);
float x1 = x - 0.5f;
float y1 = (mHeight - y - height) - 0.5f;
float x2 = (x + width) - 0.5f;
float y2 = (mHeight - y) - 0.5f;
float u1 = x / float(mWidth);
float v1 = y / float(mHeight);
float u2 = (x + width) / float(mWidth);
float v2 = (y + height) / float(mHeight);
float quad[4][6] = {{x1, y1, 0.0f, 1.0f, u1, v2},
{x2, y1, 0.0f, 1.0f, u2, v2},
{x2, y2, 0.0f, 1.0f, u2, v1},
{x1, y2, 0.0f, 1.0f, u1, v1}}; // x, y, z, rhw, u, v
mRenderer->startScene();
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, quad, 6 * sizeof(float));
mRenderer->endScene();
device->SetTexture(0, NULL);
RECT rect =
{
x, mHeight - y - height,
x + width, mHeight - y
};
HRESULT result = mSwapChain->Present(&rect, &rect, NULL, NULL, 0);
mRenderer->markAllStateDirty();
if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DRIVERINTERNALERROR)
{
return EGL_BAD_ALLOC;
}
// On Windows 8 systems, IDirect3DSwapChain9::Present sometimes returns 0x88760873 when the windows is
// in the process of entering/exiting fullscreen. This code doesn't seem to have any documentation. The
// device appears to be ok after emitting this error so simply return a failure to swap.
if (result == 0x88760873)
{
return EGL_BAD_NATIVE_WINDOW;
}
// http://crbug.com/313210
// If our swap failed, trigger a device lost event. Resetting will work around an AMD-specific
// device removed bug with lost contexts when reinstalling drivers.
if (FAILED(result))
{
mRenderer->notifyDeviceLost();
return EGL_CONTEXT_LOST;
}
return EGL_SUCCESS;
}
void MenuHandler::render()
{
if (!enabled)
return;
sprite->Begin(D3DXSPRITE_ALPHABLEND);
IDirect3DDevice9* device;
sprite->GetDevice(&device);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
if (selectedMode == MAIN_MENU)
{
int jitter = std::rand() % 100;
if (jitter < 95)
jitter = 0;
else
jitter = std::rand() % 100 - 50;
// Draw main menu
D3DXVECTOR3 currentPos;
currentPos.x = (float) screenWidth / 2.0f - 192 + jitter;
currentPos.y = (float) screenHeight / 2.0f + jitter;
currentPos.z = 0;
float scaleFactorX = screenWidth / 1024.0f;
float scaleFactorY = screenHeight / 819.0f;
D3DXMATRIX origTrans, newTrans;
sprite->GetTransform(&origTrans);
D3DXMatrixScaling(&newTrans, scaleFactorX, scaleFactorY, 1.0f);
sprite->SetTransform(&newTrans);
RECT area;
area.top = 0;
area.bottom = 819;
area.left = 0;
area.right = 1024;
sprite->Draw(mainMenuTexture, &area, &D3DXVECTOR3(512, 409.5f, 0),
&D3DXVECTOR3(512, 409.5f, 0), 0xFFFFFFFF);
sprite->SetTransform(&origTrans);
// Draw menu options
sprite->Draw(uiTexture, startGameRect, NULL, ¤tPos, 0xFFFFFFFF);
currentPos.y += 128;
sprite->Draw(uiTexture, quitRect, NULL, ¤tPos, 0xFFFFFFFF);
// Draw arrow next to appropriate selection
currentPos.x -= 128.0f;
currentPos.y = (float) screenHeight / 2.0f;
if (selectedOption == QUIT)
{
currentPos.y += 128;
}
sprite->Draw(uiTexture, arrowRect, NULL, ¤tPos, 0xFFFF0000);
}
else if (selectedMode == PAUSE_MENU)
{
int jitter = std::rand() % 100;
if (jitter < 95)
jitter = 0;
else
jitter = std::rand() % 100 - 50;
// Draw pause menu
D3DXVECTOR3 currentPos;
currentPos.x = (float) screenWidth / 2 - 128 + jitter;
currentPos.y = (float) screenHeight / 2 - 128 + jitter;
currentPos.z = 0;
// Draw menu options
sprite->Draw(uiTexture, continueRect, NULL, ¤tPos, 0xFFFFFFFF);
currentPos.y += 128;
sprite->Draw(uiTexture, quitRect, NULL, ¤tPos, 0xFFFFFFFF);
// Draw arrow next to appropriate selection
currentPos.x -= 128.0f;
currentPos.y = (float) screenHeight / 2 - 128;
if (selectedOption == CONTINUE)
{
// Do nothing
}
else if (selectedOption == QUIT)
{
currentPos.y += 128;
}
sprite->Draw(uiTexture, arrowRect, NULL, ¤tPos, 0xFFFF0000);
}
else if (selectedMode == LOADING)
{
// Show loading screen, then wait for player to hit A or Start
sprite->Draw(loadingbgTexture, NULL, &D3DXVECTOR3(512, 0, 0),
&D3DXVECTOR3((float) screenWidth / 2.0f, 0, 0), 0xFFFFFFFF);
if (loadingComplete)
{
RECT doneLoading;
doneLoading.top = 128;
doneLoading.bottom = 256;
doneLoading.left = 0;
doneLoading.right = 512;
sprite->Draw(loadingTextTexture, &doneLoading, &D3DXVECTOR3(256, 0, 0),
&D3DXVECTOR3((float) screenWidth / 2.0f, (float) screenHeight - 128.0f, 0), 0xFFFFFFFF);
}
else
{
RECT loading;
loading.top = 0;
loading.bottom = 128;
loading.left = 0;
loading.right = 512;
sprite->Draw(loadingTextTexture, &loading, &D3DXVECTOR3(256, 0, 0),
&D3DXVECTOR3((float) screenWidth / 2.0f, (float) screenHeight - 128.0f, 0), 0xFFFFFFFF);
}
}
sprite->End();
}
