void CDeferredShadingSceneRendererCommand::ExecuteDeferredShading(CRenderManager &RenderManager)
{
CContextManager* l_ContextManager = RenderManager.GetContextManager();
l_ContextManager->EnableDeferredShadingBlendState();
CLightManager* l_LightManager = CEngine::GetSingleton().GetLightManager();
std::vector<CLight*> l_Lights = l_LightManager->GetResourcesVector();
size_t l_Size = l_Lights.size();
int l_Width = l_ContextManager->GetFrameBufferWidth();
int l_Height = l_ContextManager->GetFrameBufferHeight();
ActivateTextures();
for (size_t i = 0; i < l_Size; ++i)
{
if (l_Lights[i]->GetActive())
{
CEngine::GetSingleton().GetEffectManager()->SetLightConstants(0, l_Lights[i]);
m_RenderableObjectTechnique->GetEffectTechnique()->SetConstantBuffer(1, &CEffectManager::m_LightEffectParameters);
RenderManager.DrawScreenQuad(m_RenderableObjectTechnique->GetEffectTechnique(), NULL, 0, 0, 1.0f, 1.0f, CColor(v4fZERO));
}
}
CEngine::GetSingleton().GetRenderManager()->GetContextManager()->DisableAlphaBlendState();
}
void CDeferredShadingSceneRendererCommand::SecondPass(CRenderManager &RenderManager)
{
RenderManager.GetContextManager()->EnableDeferredShadingBlendState();
RenderManager.GetContextManager()->SetRasterizerState(CContextManager::RS_CULL_FRONT); //Back(far) faces only
D3D11_DEPTH_STENCIL_DESC depthstencil_desc;
depthstencil_desc.DepthEnable = FALSE;
depthstencil_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
depthstencil_desc.DepthFunc = D3D11_COMPARISON_LESS;
depthstencil_desc.StencilEnable = TRUE;
depthstencil_desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
depthstencil_desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
depthstencil_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthstencil_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
depthstencil_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_INVERT;
depthstencil_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthstencil_desc.BackFace.StencilFunc = D3D11_COMPARISON_NOT_EQUAL;
depthstencil_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
depthstencil_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_ZERO;
depthstencil_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
//Stencil function is 'Equal' (Stencil ref = zero)
HRESULT l_Result = CEngine::GetSingleton().GetRenderManager()->GetContextManager()->GetDevice()->CreateDepthStencilState(&depthstencil_desc, &m_DepthStencilState);
RenderManager.GetContextManager()->UnsetRenderTargets();
UINT l_StencilRef = 0;
RenderManager.GetContextManager()->GetDeviceContext()->OMSetDepthStencilState(m_DepthStencilState, l_StencilRef);
//Always clears Stencil to zero
}
void CDirectionalLight::SetBlackAndWhiteMap(CRenderManager &RenderManager, bool Blurred)
{
CDynamicTexture* l_Texture = m_BlackAndWhiteMap;
if (Blurred)
l_Texture = m_BlackAndWhiteBlurredMap;
if (l_Texture == NULL)
{
assert(false);
return;
}
Vect3f l_ShadowMapFrameDisplacement = v3fZERO;
CGameObject* l_PlayerGameObject = CEngine::GetSingleton().GetGameObjectManager()->GetPlayer();
CRenderableObject* l_Player = l_PlayerGameObject->GetRenderableObject();
Vect3f l_PlayerPos = l_Player->GetPosition();
SetPosition(l_PlayerPos + m_PlayerOffset);
unsigned int l_ShadowMapWidth = l_Texture->GetWidth();
unsigned int l_ShadowMapHeight = l_Texture->GetHeight();
ID3D11RenderTargetView *l_RenderTargetViews[1];
l_RenderTargetViews[0] = l_Texture->GetRenderTargetView();
D3D11_VIEWPORT m_viewport;
m_viewport.Width = (float)l_ShadowMapWidth;
m_viewport.Height = (float)l_ShadowMapHeight;
m_viewport.MinDepth = 0.0f;
m_viewport.MaxDepth = 1.0f;
m_viewport.TopLeftX = 0.0f;
m_viewport.TopLeftY = 0.0f;
RenderManager.GetContextManager()->GetDeviceContext()->RSSetViewports(1, &m_viewport);
RenderManager.GetContextManager()->SetRenderTargets(1, l_RenderTargetViews, l_Texture->GetDepthStencilView());
}
void CDrawQuadRendererCommand::Execute(CRenderManager &RenderManager)
{
if (m_Material) { m_Material->Apply(); }
ActivateTextures();
RenderManager.DrawScreenQuad(m_RenderableObjectTechnique->GetEffectTechnique(),NULL,0,0,1.0f,1.0f,CColor(1.0f, 1.0f, 1.0f, 1.0f));
}
void CDeferredShadingSceneRendererCommand::FirstPast(CRenderManager &RenderManager)
{
CContextManager* l_ContextManager = RenderManager.GetContextManager();
l_ContextManager->Clear(false, true);
l_ContextManager->EnableDeferredShadingBlendState();
l_ContextManager->SetRasterizerState(CContextManager::RS_CULL_BACK); //Front (near) faces only
D3D11_DEPTH_STENCIL_DESC depthstencil_desc;
depthstencil_desc.DepthEnable = TRUE;
depthstencil_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
depthstencil_desc.DepthFunc = D3D11_COMPARISON_LESS;
depthstencil_desc.StencilEnable = TRUE;
depthstencil_desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
depthstencil_desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
depthstencil_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthstencil_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INVERT;
depthstencil_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthstencil_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthstencil_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthstencil_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_INVERT;
depthstencil_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthstencil_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
HRESULT l_Result = CEngine::GetSingleton().GetRenderManager()->GetContextManager()->GetDevice()->CreateDepthStencilState(&depthstencil_desc, &m_DepthStencilState);
UINT l_StencilRef = 0;
l_ContextManager->UnsetColorRenderTarget();
l_ContextManager->GetDeviceContext()->OMSetDepthStencilState(m_DepthStencilState, l_StencilRef);
}
void CDeferredShadingSceneRendererCommand::ExecuteDeferredShadingUsingLightVolumes(CRenderManager &RenderManager)
{
CLightManager* l_LightManager = CEngine::GetSingleton().GetLightManager();
std::vector<CLight*> l_Lights = l_LightManager->GetResourcesVector();
size_t l_Size = l_Lights.size();
int l_Width = RenderManager.GetContextManager()->GetFrameBufferWidth();
int l_Height = RenderManager.GetContextManager()->GetFrameBufferHeight();
ActivateTextures();
for (size_t i = 0; i<l_Size; ++i)
{
/*Only 1 light*/
if (l_Lights[i]->GetActive())
{
CEngine::GetSingleton().GetEffectManager()->SetLightConstants(0, l_Lights[i]);
m_RenderableObjectTechnique->GetEffectTechnique()->SetConstantBuffer(1, &CEffectManager::m_LightEffectParameters);
if (l_Lights[i]->GetType() != CLight::OMNI) //
{
RenderManager.GetContextManager()->SetRasterizerState(CContextManager::RS_SOLID);
RenderManager.DrawScreenQuad(m_RenderableObjectTechnique->GetEffectTechnique(), NULL, 0, 0, 1.0f, 1.0f, CColor(v4fZERO));
}
else
{
float l_LightRadius = l_Lights[i]->GetEndRangeAttenuation();
Mat44f l_Scale;
l_Scale.SetFromScale(l_LightRadius, l_LightRadius, l_LightRadius);
Mat44f l_LightTransform = l_Lights[i]->GetTransform();
RenderManager.GetContextManager()->SetWorldMatrix(l_Scale*l_LightTransform);
FirstPast(RenderManager);
CRenderableObjectTechnique* l_Technique = CEngine::GetSingleton().GetRenderableObjectTechniqueManager()->GetResource("deferred_shading_omnilight_sphere_renderable_object_technique");
m_SphereFirstPass->Render(&RenderManager, l_Technique);
SecondPass(RenderManager);
m_SphereFirstPass->Render(&RenderManager);
}
}
}
CEngine::GetSingleton().GetRenderManager()->GetContextManager()->DisableAlphaBlendState();
}
/*
Renders entity
*/
void CEntity::Render(unsigned int &prevMeshID) const
{
if (mRenderEntity)
{
CRenderManager* rm = CRenderManager::GetInstance();
ID3D11DeviceContext* deviceContext = rm->GetDeviceContext();
geom::CMesh* mesh = mTemplate->mMesh;
if (mesh != NULL)
{
if (mesh->GetUID() != prevMeshID)
{
/* Sets the buffers */
ID3D11Buffer* vertexBuffer = mesh->GetVertexBuffer();
ID3D11Buffer* indexBuffer = mesh->GetIndexBuffer();
UINT stride = mesh->GetVertexSize();
UINT offset = 0;
deviceContext->IASetVertexBuffers( 0, 1, &vertexBuffer, &stride, &offset );
deviceContext->IASetIndexBuffer( indexBuffer, DXGI_FORMAT_R16_UINT, 0 );
deviceContext->IASetPrimitiveTopology( mesh->GetTopology() );
/* Sets texture */
ID3D11ShaderResourceView* texture = mesh->GetTexture();
if (texture != NULL)
{
ID3D11SamplerState* sample = mesh->GetSample();
int startSlot = mesh->GetStartSlot();
deviceContext->PSSetShaderResources( startSlot, 1, &texture );
deviceContext->PSSetSamplers( startSlot, 1, &sample );
deviceContext->RSSetState( mTemplate->mRasterState );
}
}
deviceContext->DrawIndexed( mesh->GetNumberOfIndices(), 0, 0 );
prevMeshID = mesh->GetUID();
}
}
}
void CGenerateBlackAndWhiteMapsSceneRendererCommand::Execute(CRenderManager &RenderManager)
{
CLightManager* l_LightManager = CEngine::GetSingleton().GetLightManager();
std::vector<CLight*> l_Lights = l_LightManager->GetResourcesVector();
size_t l_Size = l_Lights.size();
ActivateTextures();
//We are going to render from camera perspective
//RenderManager.GetContextManager()->SetMatrices(RenderManager.GetCurrentCamera());
for (size_t i = 0; i<l_Size; ++i)
{
if (l_Lights[i]->GetActive() && l_Lights[i]->GetGenerateShadowMap())
{
l_Lights[i]->SetBlackAndWhiteMap(RenderManager, false); //Set BlackAndWhiteTexture as rendertarget
//Doens't change matrix, beacuse we must render from camera perspective
CEngine::GetSingleton().GetEffectManager()->SetBlackAndWhiteLightConstants(l_Lights[i]);
RenderManager.DrawScreenQuad(m_RenderableObjectTechnique->GetEffectTechnique(), NULL, 0, 0, 1.0f, 1.0f, CColor(1.0f, 1.0f, 1.0f, 1.0f));
CMaterial* l_GaussianFilterMaterial = CEngine::GetSingleton().GetMaterialManager()->GetResource("GaussianFilterMaterial");
CMaterial* l_GuiMaterial = CEngine::GetSingleton().GetMaterialManager()->GetResource("GUIMaterial");
RenderManager.GetContextManager()->UnsetRenderTargets();
RenderManager.GetContextManager()->SetDefaultViewPort();
l_Lights[i]->SetBlackAndWhiteMap(RenderManager, true);
CPoolRenderableObjectTechnique* l_GaussianFilterPool = CEngine::GetSingleton().GetRenderableObjectTechniqueManager()->GetPoolRenderableObjectTechniques().GetResource("gaussian_filter_pool_renderable_object_technique");
l_GaussianFilterPool->Apply();
l_Lights[i]->GetBlackAndWhiteMap()->Activate(0);
l_GaussianFilterMaterial->Apply();
RenderManager.DrawScreenQuad(l_GaussianFilterMaterial->GetRenderableObjectTechnique()->GetEffectTechnique(), NULL, 0, 0, 1.0f, 1.0f, CColor(0.0, 0.0, 0.0, 0.0));
}
}
RenderManager.GetContextManager()->UnsetRenderTargets();
RenderManager.GetContextManager()->SetDefaultViewPort();
}
void CDirectionalLight::SetShadowMap(CRenderManager &RenderManager)
{
if (m_ShadowMap == NULL)
{
assert(false);
return;
}
Vect3f l_ShadowMapFrameDisplacement = v3fZERO;
CGameObject* l_PlayerGameObject = CEngine::GetSingleton().GetGameObjectManager()->GetPlayer();
CRenderableObject* l_Player = l_PlayerGameObject->GetRenderableObject();
Vect3f l_PlayerPos = l_Player->GetPosition();
SetPosition(l_PlayerPos + m_PlayerOffset);
m_ViewShadowMap.SetIdentity();
m_ViewShadowMap.SetFromLookAt(m_Position, m_Position+m_Direction, v3fY);
unsigned int l_ShadowMapWidth=m_ShadowMap->GetWidth();
unsigned int l_ShadowMapHeight=m_ShadowMap->GetHeight();
m_ProjectionShadowMap.SetFromOrtho(m_OrthoShadowMapSize.x,m_OrthoShadowMapSize.y, 0.1f, m_EndRangeAttenuation);
CEffectManager::m_SceneEffectParameters.m_View=m_ViewShadowMap;
CEffectManager::m_SceneEffectParameters.m_Projection=m_ProjectionShadowMap;
ID3D11RenderTargetView *l_RenderTargetViews[1];
l_RenderTargetViews[0]=m_ShadowMap->GetRenderTargetView();
D3D11_VIEWPORT m_viewport;
m_viewport.Width=(float)l_ShadowMapWidth;
m_viewport.Height=(float)l_ShadowMapHeight;
m_viewport.MinDepth=0.0f;
m_viewport.MaxDepth=1.0f;
m_viewport.TopLeftX=0.0f;
m_viewport.TopLeftY=0.0f;
RenderManager.GetContextManager()->GetDeviceContext()->RSSetViewports(1, &m_viewport);
RenderManager.GetContextManager()->SetRenderTargets(1, l_RenderTargetViews, m_ShadowMap->GetDepthStencilView());
}
bool CDeferredShadingSceneRendererCommand::IsCameraInsideLight(CRenderManager &RenderManager, COmniLight* Light)
{
Vect3f l_CameraPos = RenderManager.GetCurrentCamera().GetPosition();
Vect3f l_LightPosition = Light->GetPosition();
float l_Distance = (l_CameraPos - l_LightPosition).Length();
if (l_Distance >= Light->GetEndRangeAttenuation()*1.2f)
{
//Use the front-face cull method as described above with those render states. Turn the stencil buffer off and don't mess with it.
return false;
}
else
{
//(The first thing you need to (do is make sure that on your depth / stencil buffer, the stencil buffer is one solid value all the way across.I make my value 4.0 all over it.
return true;
}
}
void CBillboard::RenderBySoftware ( CRenderManager &_RM, const CColor &_Color )
{
TCOLOREDTEXTURE1_VERTEX l_Points[4];
unsigned short l_Indexes[6] = { 0, 2, 3, 1 };
unsigned long color_aux = _Color.GetUint32Argb();
l_Points[0].x = m_PointA.x;
l_Points[0].y = m_PointA.y;
l_Points[0].z = m_PointA.z;
l_Points[0].tu = 0.0f;
l_Points[0].tv = 0.0f;
l_Points[0].color = color_aux;
l_Points[1].x = m_PointB.x;
l_Points[1].y = m_PointB.y;
l_Points[1].z = m_PointB.z;
l_Points[1].tu = 1.0f;
l_Points[1].tv = 0.0f;
l_Points[1].color = color_aux;
l_Points[2].x = m_PointC.x;
l_Points[2].y = m_PointC.y;
l_Points[2].z = m_PointC.z;
l_Points[2].tu = 0.0f;
l_Points[2].tv = 1.0f;
l_Points[2].color = color_aux;
l_Points[3].x = m_PointD.x;
l_Points[3].y = m_PointD.y;
l_Points[3].z = m_PointD.z;
l_Points[3].tu = 1.0f;
l_Points[3].tv = 1.0f;
l_Points[3].color = color_aux;
LPDIRECT3DDEVICE9 Device = _RM.GetDevice();
Device->SetTexture( 0, m_Texture->GetDXTexture() );
Device->SetFVF((DWORD ) TCOLOREDTEXTURE1_VERTEX::GetFVF() );
Device->DrawIndexedPrimitiveUP( D3DPT_TRIANGLEFAN, 0, 4, 2, l_Indexes ,D3DFMT_INDEX16, l_Points, sizeof(TCOLOREDTEXTURE1_VERTEX) );
}
void CUnsetRenderTargetSceneRendererCommand::Execute(CRenderManager &RenderManager)
{
RenderManager.GetContextManager()->UnsetRenderTargets();
}
void Start()
{
m_RenderManager.Start(SamplingFrequency, &m_InSource, &m_Renderer);
}
void GLAnimationCanvas::OnMouse(wxMouseEvent& event)
{
if (m_iType == TYPE_CURVE)
{
wxPoint wxpt = event.GetPosition();
Spline::Point pt(wxpt.x, wxpt.y);
if (event.ButtonDown(wxMOUSE_BTN_LEFT))
{
size_t index;
if(m_spline->findKont(pt, index))
{
m_selectedIndex = index;
}
else
{
m_selectedIndex = -1;
}
}
else if(event.ButtonDown(wxMOUSE_BTN_RIGHT))
{
size_t index;
if(m_spline->findKont(pt, index))
{
m_spline->removeKnot(index);
m_selectedIndex = -1;
}
else
{
m_selectedIndex = m_spline->addKnots(pt);
}
}
else if (event.Dragging())
{
if(m_selectedIndex >= 0)
{
m_spline->setKnot(m_selectedIndex, pt);
}
}
}
else if (m_iType == TYPE_ANIMATION)
{
if(event.ButtonDown(wxMOUSE_BTN_RIGHT))
{
ShowCursor(false);
SetFocus();
if (!HasCapture())
{
CaptureMouse();
}
m_bRightDown = true;
}
else if(event.ButtonUp(wxMOUSE_BTN_RIGHT))
{
ShowCursor(true);
if (HasCapture())
{
ReleaseMouse();
}
ResetKeyStates();
m_bRightDown = false;
}
else if(event.ButtonDown(wxMOUSE_BTN_LEFT))
{
ShowCursor(false);
SetFocus();
if (!HasCapture())
{
CaptureMouse();
}
m_bLeftDown = true;
}
else if(event.ButtonUp(wxMOUSE_BTN_LEFT))
{
ShowCursor(true);
if (!HasCapture())
{
CaptureMouse();
}
ResetKeyStates();
m_bLeftDown = false;
}
else if(event.Dragging())
{
wxPoint curPos = event.GetPosition();
wxPoint pnt = ClientToScreen(curPos);
SetCursorPos(pnt.x, pnt.y);
CRenderManager* pRenderMgr = CRenderManager::GetInstance();
if (m_bRightDown)
{
int nDeltaX = curPos.x - m_lastPosition.x;
int nDeltaY = curPos.y - m_lastPosition.y;
wxSize clientSize = GetClientSize();
pRenderMgr->GetCamera()->Yaw((float)nDeltaX / clientSize.x);
pRenderMgr->GetCamera()->Pitch((float)nDeltaY / clientSize.y);
}
}
else if(event.GetWheelAxis() == wxMOUSE_WHEEL_VERTICAL)
{
kmVec3 vec3Speed;
kmVec3Fill(&vec3Speed, SHIFTWHEELSPEED, SHIFTWHEELSPEED, SHIFTWHEELSPEED);
if (event.GetWheelRotation() > 0)
{
CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT));
}
else if (event.GetWheelRotation() < 0)
{
kmVec3Scale(&vec3Speed, &vec3Speed, -1.0f);
CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT));
}
}
m_lastPosition = event.GetPosition();
}
}
// -----------------------------------------
// MÈTODES PRINCIPALS
// -----------------------------------------
void CEndRenderSceneRendererCommand::Execute( CRenderManager &_RM )
{
_RM.GetDevice()->EndScene();
}
void CBillboard::RenderByHardware ( CRenderManager &_RM, const CColor &_Color )
{
//CORE->GetRenderableObjectsTechniqueManager()->GetPoolRenderableObjectTechniques().GetResource(
std::string l_TechniqueName = "DrawSingleTextureTechnique"; // CORE->GetEffectsManager()->GetTechniqueEffectNameByVertexDefault( ( int ) TGEOMETRYCOLORTEXTURA1VERTEX::GetVertexType() );
CEffectTechnique* l_pTechnique = CORE->GetEffectManager()->GetEffectTechnique ( l_TechniqueName );
CEffect* l_pEffect = l_pTechnique->GetEffect();
l_pTechnique->BeginRender();
LPD3DXEFFECT l_Effect = l_pTechnique->GetEffect()->GetD3DEffect();
if ( l_Effect != NULL )
{
l_Effect->SetTechnique ( l_pTechnique->GetD3DTechnique() );
UINT l_NumPasses;
if ( SUCCEEDED ( l_Effect->Begin ( &l_NumPasses, 0 ) ) )
{
for ( UINT iPass = 0; iPass < l_NumPasses; iPass++ )
{
l_Effect->BeginPass(iPass);
//_RM->DrawColoredQuad2DTexturedInPixels ( _Color, _U0, _V0, _U1, _V1 );
TCOLOREDTEXTURE1_VERTEX l_Points[4];
unsigned short l_Indexes[6] = { 0, 2, 3, 1 };
unsigned long color_aux = _Color.GetUint32Argb();
l_Points[0].x = m_PointA.x;
l_Points[0].y = m_PointA.y;
l_Points[0].z = m_PointA.z;
l_Points[0].tu = 0.0f;
l_Points[0].tv = 0.0f;
l_Points[0].color = color_aux;
l_Points[1].x = m_PointB.x;
l_Points[1].y = m_PointB.y;
l_Points[1].z = m_PointB.z;
l_Points[1].tu = 1.0f;
l_Points[1].tv = 0.0f;
l_Points[1].color = color_aux;
l_Points[2].x = m_PointC.x;
l_Points[2].y = m_PointC.y;
l_Points[2].z = m_PointC.z;
l_Points[2].tu = 0.0f;
l_Points[2].tv = 1.0f;
l_Points[2].color = color_aux;
l_Points[3].x = m_PointD.x;
l_Points[3].y = m_PointD.y;
l_Points[3].z = m_PointD.z;
l_Points[3].tu = 1.0f;
l_Points[3].tv = 1.0f;
l_Points[3].color = color_aux;
Mat44f mat, rotYaw, rotPitch, rotRoll;
//mat.SetIdentity ( );
//rotYaw.SetIdentity ( );
//rotPitch.SetIdentity ( );
//rotRoll.SetIdentity ( );
//mat.Translate( GetPosition ( ) );
///*rotPitch.SetRotByAngleX( mathUtils::Deg2Rad<float> ( GetPitch()) );
//rotYaw.SetRotByAngleY ( mathUtils::Deg2Rad<float> ( GetYaw()) );
//rotRoll.SetRotByAngleZ ( mathUtils::Deg2Rad<float> ( GetRoll()) ); */
//mat = mat * rotYaw * rotPitch * rotRoll;
//_RM->SetTransform ( mat );
LPDIRECT3DDEVICE9 Device = _RM.GetDevice();
Device->SetTexture( 0, m_Texture->GetDXTexture() );
if ( SUCCEEDED ( Device->SetVertexDeclaration( TCOLOREDTEXTURE1_VERTEX::GetVertexDeclaration() ) ) )
{
Device->DrawIndexedPrimitiveUP( D3DPT_TRIANGLEFAN, 0, 4 ,2 , l_Indexes, D3DFMT_INDEX16, l_Points, sizeof( TCOLOREDTEXTURE1_VERTEX ) );
}
l_Effect->EndPass();
}
l_Effect->End();
}
}
}
void CScissorRectSceneRendererCommand::Execute(CRenderManager &RM)
{
RM.GetDevice()->SetScissorRect(&m_Rect);
RM.GetDevice()->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
}
void CEnableAlphaBlendSceneRendererCommand::Execute(CRenderManager &RenderManager)
{
RenderManager.GetContextManager()->EnableAlphaBlendState();
}
