void DrawClearQuadMRT( FRHICommandList& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, bool bClearColor, int32 NumClearColors, const FLinearColor* ClearColorArray, bool bClearDepth, float Depth, bool bClearStencil, uint32 Stencil, FIntPoint ViewSize, FIntRect ExcludeRect )
{
ClearQuadSetup( RHICmdList, FeatureLevel, bClearColor, NumClearColors, ClearColorArray, bClearDepth, Depth, bClearStencil, Stencil );
// Draw a fullscreen quad
if(ExcludeRect.Width() > 0 && ExcludeRect.Height() > 0)
{
// with a hole in it
FVector4 OuterVertices[4];
OuterVertices[0].Set( -1.0f, 1.0f, Depth, 1.0f );
OuterVertices[1].Set( 1.0f, 1.0f, Depth, 1.0f );
OuterVertices[2].Set( 1.0f, -1.0f, Depth, 1.0f );
OuterVertices[3].Set( -1.0f, -1.0f, Depth, 1.0f );
float InvViewWidth = 1.0f / ViewSize.X;
float InvViewHeight = 1.0f / ViewSize.Y;
FVector4 FractionRect = FVector4(ExcludeRect.Min.X * InvViewWidth, ExcludeRect.Min.Y * InvViewHeight, (ExcludeRect.Max.X - 1) * InvViewWidth, (ExcludeRect.Max.Y - 1) * InvViewHeight);
FVector4 InnerVertices[4];
InnerVertices[0].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.X), FMath::Lerp(1.0f, -1.0f, FractionRect.Y), Depth, 1.0f );
InnerVertices[1].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.Z), FMath::Lerp(1.0f, -1.0f, FractionRect.Y), Depth, 1.0f );
InnerVertices[2].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.Z), FMath::Lerp(1.0f, -1.0f, FractionRect.W), Depth, 1.0f );
InnerVertices[3].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.X), FMath::Lerp(1.0f, -1.0f, FractionRect.W), Depth, 1.0f );
FVector4 Vertices[10];
Vertices[0] = OuterVertices[0];
Vertices[1] = InnerVertices[0];
Vertices[2] = OuterVertices[1];
Vertices[3] = InnerVertices[1];
Vertices[4] = OuterVertices[2];
Vertices[5] = InnerVertices[2];
Vertices[6] = OuterVertices[3];
Vertices[7] = InnerVertices[3];
Vertices[8] = OuterVertices[0];
Vertices[9] = InnerVertices[0];
DrawPrimitiveUP(RHICmdList, PT_TriangleStrip, 8, Vertices, sizeof(Vertices[0]) );
}
else
{
// without a hole
FVector4 Vertices[4];
Vertices[0].Set( -1.0f, 1.0f, Depth, 1.0f );
Vertices[1].Set( 1.0f, 1.0f, Depth, 1.0f );
Vertices[2].Set( -1.0f, -1.0f, Depth, 1.0f );
Vertices[3].Set( 1.0f, -1.0f, Depth, 1.0f );
DrawPrimitiveUP(RHICmdList, PT_TriangleStrip, 2, Vertices, sizeof(Vertices[0]));
}
}
// draw
void AnimationObject::Draw(void) {
auto p_device = DeviceHolder::Instance().GetDevice();
p_texture_animation_ -> UpdateAnimation();
Vertex2D data[] ={
{D3DXVECTOR3(pos_.x - size_.x / 2, pos_.y - size_.y / 2, 0.0f), 1.0f, 0xffffffff, D3DXVECTOR2(0.0f, 0.0f)},
{D3DXVECTOR3(pos_.x + size_.x / 2, pos_.y - size_.y / 2, 0.0f), 1.0f, 0xffffffff, D3DXVECTOR2(1.0f, 0.0f)},
{D3DXVECTOR3(pos_.x - size_.x / 2, pos_.y + size_.y / 2, 0.0f), 1.0f, 0xffffffff, D3DXVECTOR2(0.0f, 1.0f)},
{D3DXVECTOR3(pos_.x + size_.x / 2, pos_.y + size_.y / 2, 0.0f), 1.0f, 0xffffffff, D3DXVECTOR2(1.0f, 1.0f)},
};
D3DXVECTOR2 texture_uv_ = p_texture_animation_ -> GetTextureUV();
D3DXVECTOR2 texture_uv_offset_ = p_texture_animation_->GetTextureUVOffset();
if (move_direction_ == DIRECTION_LEFT) {
texture_uv_.x += texture_uv_offset_.x;
texture_uv_offset_.x *= -1;
}
data[0].tex = D3DXVECTOR2(texture_uv_.x, texture_uv_.y);
data[1].tex = D3DXVECTOR2(texture_uv_.x + texture_uv_offset_.x, texture_uv_.y);
data[2].tex = D3DXVECTOR2(texture_uv_.x, texture_uv_.y + texture_uv_offset_.y);
data[3].tex = D3DXVECTOR2(texture_uv_.x + texture_uv_offset_.x, texture_uv_.y + texture_uv_offset_.y);
TextureManagerHolder::Instance().GetTextureManager().SetTexture(texture_id_);
p_device->SetFVF(kVertexFVF2D);
p_device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, data, sizeof(Vertex2D));
}
bool DX9RenderSystem::DrawSprite( int x, int y, int sx, int sy, int tx, int ty, int tsx, int tsy, Texture* tex, unsigned int color )
{
// Get the place on the screen
float fx = (float)(x) - (float)mSize.x / 2 - 0.5f;
float fy = (float)(y) - (float)mSize.y / 2 - 0.5f;
// Get the width for the screen
float fsx = (float)sx;// / (float)mSize.x;
float fsy = (float)sy;// / (float)mSize.y;
// Get the place for the TextureBase
float ftx = (float)tx / (float)tex->GetWidth( );
float fty = (float)ty / (float)tex->GetHeight( );
// Get the width for the TextureBase
float ftsx = (float)tsx / (float)tex->GetWidth( );
float ftsy = (float)tsy / (float)tex->GetHeight( );
struct VertDef { Vector3 pos; Vector2 uv; unsigned int color; } verts[] =
{
{ Vector3( fx, fy, 1 ), Vector2( ftx, fty ), color },
{ Vector3( fx, fy+fsy, 1 ), Vector2( ftx, fty+ftsy ), color },
{ Vector3( fx+fsx, fy, 1 ), Vector2( ftx+ftsx, fty ), color },
{ Vector3( fx+fsx, fy+fsy, 1 ), Vector2( ftx+ftsx, fty+ftsy ), color }
};
SetTexture( 0, tex );
DrawPrimitiveUP( PrimitiveType::TriangleStrip, 2, &verts, sizeof( VertDef ) );
return true;
};
void BaseDemo::ShowBlock(int x1, int y1, int x2, int y2, const XMFLOAT4& color, float dt /*= 0*/)
{
float x = (float)x1;
float y = (float)y1;
float h = (float)y2 - y1;
float w = (float)x2 - x1;
XMFLOAT3 LeftTop = XMFLOAT3(x, y, 0.0f);
XMFLOAT3 RightTop = XMFLOAT3(x + w, y, 0.0f);
XMFLOAT3 LeftBottom = XMFLOAT3(x, (y + h), 0.0f);
XMFLOAT3 RightBottom = XMFLOAT3(x + w, (y + h), 0.0f);
VertexPositionColorTexture vertices[] =
{
//正面的四个点
{ LeftBottom, color, XMFLOAT2(0, 1) },
{ LeftTop, color, XMFLOAT2(0, 0) },
{ RightTop, color, XMFLOAT2(1, 0) },
{ LeftBottom, color, XMFLOAT2(0, 1) },
{ RightTop, color, XMFLOAT2(1, 0) },
{ RightBottom, color, XMFLOAT2(1, 1) }
};
XMMATRIX rz = XMMatrixRotationZ(XM_PI *dt);
//先平移为原点，绕着原点旋转, 转换到平行投影的中点为（w/2,h/2）坐标系。Y 是颠倒的，在旋转
XMMATRIX rTmp = XMMatrixTranslation(-x, -y, 0.0)* rz * XMMatrixTranslation(x, y, 0.0);
XMMATRIX toTexSpace = GetShow2DMatrix(mClientWidth, mClientHeight);
toTexSpace = rTmp * toTexSpace;
DrawPrimitiveUP(PRIMITIVE_TRIANGLELIST, 6, vertices, toTexSpace);
}
//==============================================================================
// draw
//------------------------------------------------------------------------------
void Parpix::draw(Renderer *renderer,Sprite2D* sprite) {
const auto pDevice = renderer->getDevice();
auto shader = renderer->getShader();
shader->setPixShader("ps_parpix.cso");
auto constTable = shader->getNowPixShader()->_constTable;
pDevice->SetTexture(0,renderer->getNormalDepthTex());
pDevice->SetTexture(1,renderer->getPosTex());
pDevice->SetTexture(2,renderer->getColorTex());
const SIZE size = App::instance().getWindowSize();
const float w = (float)size.cx;
const float h = (float)size.cy;
Vec3 dir[4];
Vec3 col[4];
static float f = 0;
f += 0.02f;
col[0] = Vec3(1, 1, 0.1f);
col[1] = Vec3(0.1f, 0.1f, 1);
col[2] = Vec3(1, 1, 0.1f);
col[3] = Vec3(0.3f, 0.3f, 1);
for(int i = 0; i < 4; i++) {
dir[i] = Vec3(cosf(f + D3DX_PI * 0.5f * i),1,sinf(f + D3DX_PI * 0.5f * i));
dir[i] *= 400;
dir[i].y = 10;
}
constTable->SetFloatArray(pDevice,"gDLight",(float*)dir,sizeof(float) * 3 * 4);
constTable->SetFloatArray(pDevice,"gDLightCol",(float*)col,sizeof(float) * 3 * 4);
constTable->SetFloatArray(pDevice,"gCameraPos",(float*)&renderer->getCamera()->getCurrentCamera()->getPosP(),sizeof(float) * 3);
constTable->SetFloat(pDevice,"gFar",2000);
struct T4VERTEX {
float p[4];
float t[2];
} Vertex[4] = {
{0.0f,0,0.1f,1.0f,0.0f,0.0f},
{w,0,0.1f,1.0f,1.0f,0.0f},
{w,h,0.1f,1.0f,1.0f,1.0f},
{0.0f,h,0.1f,1.0f,0.0f,1.0f},
};
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
pDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN,2,Vertex,sizeof(T4VERTEX));
pDevice->SetFVF(NULL);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA); // ソース
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA); // デスト
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
}
void DrawClearQuadMRT( FRHICommandList& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, bool bClearColor, int32 NumClearColors, const FLinearColor* ClearColorArray, bool bClearDepth, float Depth, bool bClearStencil, uint32 Stencil )
{
ClearQuadSetup( RHICmdList, FeatureLevel, bClearColor, NumClearColors, ClearColorArray, bClearDepth, Depth, bClearStencil, Stencil );
// without a hole
FVector4 Vertices[4];
Vertices[0].Set( -1.0f, 1.0f, Depth, 1.0f );
Vertices[1].Set( 1.0f, 1.0f, Depth, 1.0f );
Vertices[2].Set( -1.0f, -1.0f, Depth, 1.0f );
Vertices[3].Set( 1.0f, -1.0f, Depth, 1.0f );
DrawPrimitiveUP(RHICmdList, PT_TriangleStrip, 2, Vertices, sizeof(Vertices[0]));
}
void BaseDemo::DrawPrimitiveUP(PrimitiveType PrimitiveType, unsigned int PrimitiveCount, VertexPositionColor *pVertexs, const XMMATRIX &model /*= XMMatrixIdentity()*/, ID3D11ShaderResourceView*pTexture /*= NULL*/)
{
std::vector<VertexPositionColorTexture> vertex;
vertex.resize(PrimitiveCount);
for (uint32 i = 0; i < PrimitiveCount; ++i)
{
VertexPositionColorTexture& pPoint = vertex[i];
pPoint.color = pVertexs[i].color;
pPoint.position = pVertexs[i].position;
}
DrawPrimitiveUP(PrimitiveType, PrimitiveCount, &vertex[0], model, pTexture);
}
void DynamicPrimitive::ShowTexEx(RECT *pDest, RECT *pSrc, int nWidth, int nHeight, ID3D11ShaderResourceView*pTexture)
{
XMFLOAT4 color(0, 0, 0, 0);
int x = pDest->left;
int y = pDest->top;
int h = pDest->bottom - pDest->top;
int w = pDest->right - pDest->left;
XMFLOAT3 LeftTop = XMFLOAT3(x, y, 0.0f);
XMFLOAT3 RightTop = XMFLOAT3(x + w, y, 0.0f);
XMFLOAT3 LeftBottom = XMFLOAT3(x, (y + h), 0.0f);
XMFLOAT3 RightBottom = XMFLOAT3(x + w, (y + h), 0.0f);
int tmpX = (float)m_nWidth*1.0f / 2.0f - x;
int tmpY = (float)m_nHeight*1.0f / 2.0f - y;
VertexPositionColorTexture vertices[] =
{
//正面的四个点
{ LeftBottom, color, XMFLOAT2(0, 1) },
{ LeftTop, color, XMFLOAT2(0, 0) },
{ RightTop, color, XMFLOAT2(1, 0) },
{ LeftBottom, color, XMFLOAT2(0, 1) },
{ RightTop, color, XMFLOAT2(1, 0) },
{ RightBottom, color, XMFLOAT2(1, 1) }
};
XMFLOAT2 textureCoordinate[4];
textureCoordinate[0].x = textureCoordinate[1].x = float(pSrc->left) / (float)nWidth;
textureCoordinate[0].y = textureCoordinate[3].y = float(pSrc->bottom) / (float)nHeight;
textureCoordinate[2].x = textureCoordinate[3].x = float(pSrc->right) / (float)nWidth;
textureCoordinate[2].y = textureCoordinate[1].y = float(pSrc->top) / (float)nHeight;
vertices[0].textureCoordinate = textureCoordinate[0];
vertices[1].textureCoordinate = textureCoordinate[1];
vertices[2].textureCoordinate = textureCoordinate[2];
vertices[3].textureCoordinate = textureCoordinate[0];
vertices[4].textureCoordinate = textureCoordinate[2];
vertices[5].textureCoordinate = textureCoordinate[3];
// Transform NDC space [-1,+1]^2 to texture space [0,1]^2
XMMATRIX toTexSpace = GetShow2DMatrix(m_nWidth, m_nHeight);
DrawPrimitiveUP(PRIMITIVE_TRIANGLELIST, 6, vertices, toTexSpace, pTexture);
}
void FD3D11DynamicRHI::IssueLongGPUTask()
{
if (GMaxRHIFeatureLevel >= ERHIFeatureLevel::SM4)
{
int32 LargestViewportIndex = INDEX_NONE;
int32 LargestViewportPixels = 0;
for (int32 ViewportIndex = 0; ViewportIndex < Viewports.Num(); ViewportIndex++)
{
FD3D11Viewport* Viewport = Viewports[ViewportIndex];
if (Viewport->GetSizeXY().X * Viewport->GetSizeXY().Y > LargestViewportPixels)
{
LargestViewportPixels = Viewport->GetSizeXY().X * Viewport->GetSizeXY().Y;
LargestViewportIndex = ViewportIndex;
}
}
if (LargestViewportIndex >= 0)
{
FD3D11Viewport* Viewport = Viewports[LargestViewportIndex];
FRHICommandList_RecursiveHazardous RHICmdList(this);
SetRenderTarget(RHICmdList, Viewport->GetBackBuffer(), FTextureRHIRef());
RHICmdList.SetBlendState(TStaticBlendState<CW_RGBA, BO_Add, BF_One, BF_One>::GetRHI(), FLinearColor::Black);
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI(), 0);
RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());
auto ShaderMap = GetGlobalShaderMap(GMaxRHIFeatureLevel);
TShaderMapRef<TOneColorVS<true> > VertexShader(ShaderMap);
TShaderMapRef<FLongGPUTaskPS> PixelShader(ShaderMap);
RHICmdList.SetLocalBoundShaderState(RHICmdList.BuildLocalBoundShaderState(GD3D11Vector4VertexDeclaration.VertexDeclarationRHI, VertexShader->GetVertexShader(), FHullShaderRHIRef(), FDomainShaderRHIRef(), PixelShader->GetPixelShader(), FGeometryShaderRHIRef()));
// Draw a fullscreen quad
FVector4 Vertices[4];
Vertices[0].Set( -1.0f, 1.0f, 0, 1.0f );
Vertices[1].Set( 1.0f, 1.0f, 0, 1.0f );
Vertices[2].Set( -1.0f, -1.0f, 0, 1.0f );
Vertices[3].Set( 1.0f, -1.0f, 0, 1.0f );
DrawPrimitiveUP(RHICmdList, PT_TriangleStrip, 2, Vertices, sizeof(Vertices[0]));
// Implicit flush. Always call flush when using a command list in RHI implementations before doing anything else. This is super hazardous.
}
}
}
// 描画（頂点数不定）
void CMglTexture::Draw( MYU_VERTEX *pMyuVertex, UINT nPrimitiveCount, BOOL bVertexRevise )
{
CreateCheck(); // Createチェック
LockedCheck();
// 頂点補正
if ( bVertexRevise )
//MglMoveVertexs1( (MYU_VERTEX1*)pMyuVertex, TEXTURE_FLOAT_ADJ, TEXTURE_FLOAT_ADJ, 2+nPrimitiveCount );
MglMoveVertexs( pMyuVertex, TEXTURE_FLOAT_ADJ, TEXTURE_FLOAT_ADJ, TEXTURE_FLOAT_ADJ, 2+nPrimitiveCount );
/*
// テクスチャの設定
MyuAssert( d3d->SetTexture(0, m_pTexture), D3D_OK,
"CMglImage::TextureDrawPrimitive() SetTexture()に失敗" );
*/
SetD3dStageTexture();
DrawPrimitiveUP( D3DPT_TRIANGLEFAN, nPrimitiveCount, pMyuVertex, sizeof(MYU_VERTEX) );
// 絵画
/*MyuAssert( d3d->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, nPrimitiveCount, pMyuVertex, sizeof(MYU_VERTEX) ), D3D_OK,
"CMglImage::TextureDrawPrimitive() DrawPrimitiveUP()に失敗" );*/
}
void BaseDemo::DrawScene()
{
SwapChainPtr->Begin();
ShowBlock(100, 100, 300, 200, { 0, 0, 1, 1 }, mTimer.TotalTime());
vector<VertexPositionColor> vertices;
vertices.resize(mClientWidth);
for (int xval = 0; xval < mClientWidth; ++xval)
{
float yval = (float)m_Curve->Evaluate(xval);
vertices[xval] = DirectX::VertexPositionColor(XMFLOAT3((float)xval, yval, 0.0f), XMFLOAT4(0.5f, 1.0f, 0.5f, 1));
}
XMMATRIX toTexSpace = GetShow2DMatrix(mClientWidth, mClientHeight);
DrawPrimitiveUP(PRIMITIVE_LINESTRIP, mClientWidth, &vertices[0], toTexSpace);
static int kkkkkk = 0;
if (kkkkkk >= mClientWidth - 1)
{
kkkkkk = 0;
}
else
{
kkkkkk++;
}
int xPos = (int)vertices[kkkkkk].position.x;
int yPos = (int)vertices[kkkkkk].position.y;
ShowBlock(xPos - 5, yPos - 5, xPos + 5, yPos + 5, XMFLOAT4(DirectX::Colors::Blue));
for (int i = 0; i < m_Curve->Size(); ++i)
{
int xPos = (int)m_Curve->Key(i);// +mClientWidth / 2;
int yPos = (int)m_Curve->Value(i);
ShowBlock(xPos - 5, yPos - 5, xPos + 5, yPos + 5, XMFLOAT4(DirectX::Colors::Red));
}
SwapChainPtr->Flip();
}
void DynamicPrimitive::ShowRect(int x1, int y1, int x2, int y2, const XMFLOAT4& color, bool bDot, float dt /*= 0*/)
{
float x = (float)x1;
float y = (float)y1;
float h = (float)y2 - y1;
float w = (float)x2 - x1;
XMFLOAT3 LeftTop = XMFLOAT3(x, y, 0.0f);
XMFLOAT3 RightTop = XMFLOAT3(x + w, y, 0.0f);
XMFLOAT3 LeftBottom = XMFLOAT3(x, (y + h), 0.0f);
XMFLOAT3 RightBottom = XMFLOAT3(x + w, (y + h), 0.0f);
VertexPositionColorTexture vertices[8] =
{
//正面的四个点
{ LeftBottom, color, XMFLOAT2(0, 1) },
{ LeftTop, color, XMFLOAT2(0, 0) },
{ LeftTop, color, XMFLOAT2(0, 0) },
{ RightTop, color, XMFLOAT2(1, 0) },
{ RightTop, color, XMFLOAT2(1, 0) },
{ RightBottom, color, XMFLOAT2(1, 1) },
{ RightBottom, color, XMFLOAT2(1, 1) },
{ LeftBottom, color, XMFLOAT2(0, 1) }
};
XMMATRIX rz = XMMatrixRotationZ(XM_PI *dt);
//先平移为原点，绕着原点旋转, 转换到平行投影的中点为（w/2,h/2）坐标系。Y 是颠倒的，在旋转
XMMATRIX rTmp = XMMatrixTranslation(-x, -y, 0.0)* rz * XMMatrixTranslation(x, y, 0.0);
XMMATRIX toTexSpace = GetShow2DMatrix(m_nWidth, m_nHeight);
toTexSpace = rTmp * toTexSpace;
// m_MaterialPtr->SetbUseGeometry(bDot);
DrawPrimitiveUP(PRIMITIVE_LINELIST, 8, vertices, toTexSpace);
}
// TODO support ExcludeRect
void DrawClearQuadMRT(FRHICommandList& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, bool bClearColor, int32 NumClearColors, const FLinearColor* ClearColorArray, bool bClearDepth, float Depth, bool bClearStencil, uint32 Stencil)
{
// Set new states
FBlendStateRHIParamRef BlendStateRHI;
if (NumClearColors <= 1)
{
BlendStateRHI = bClearColor
? TStaticBlendState<>::GetRHI()
: TStaticBlendState<CW_NONE>::GetRHI();
}
else
{
BlendStateRHI = bClearColor
? TStaticBlendState<>::GetRHI()
: TStaticBlendStateWriteMask<CW_NONE,CW_NONE,CW_NONE,CW_NONE,CW_NONE,CW_NONE,CW_NONE,CW_NONE>::GetRHI();
}
const FDepthStencilStateRHIParamRef DepthStencilStateRHI =
(bClearDepth && bClearStencil)
? TStaticDepthStencilState<
true, CF_Always,
true,CF_Always,SO_Replace,SO_Replace,SO_Replace,
false,CF_Always,SO_Replace,SO_Replace,SO_Replace,
0xff,0xff
>::GetRHI()
: bClearDepth
? TStaticDepthStencilState<true, CF_Always>::GetRHI()
: bClearStencil
? TStaticDepthStencilState<
false, CF_Always,
true,CF_Always,SO_Replace,SO_Replace,SO_Replace,
false,CF_Always,SO_Replace,SO_Replace,SO_Replace,
0xff,0xff
>::GetRHI()
: TStaticDepthStencilState<false, CF_Always>::GetRHI();
RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());
RHICmdList.SetBlendState(BlendStateRHI);
RHICmdList.SetDepthStencilState(DepthStencilStateRHI);
auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
// Set the new shaders
TShaderMapRef<TOneColorVS<true> > VertexShader(ShaderMap);
FOneColorPS* PixelShader = NULL;
// Set the shader to write to the appropriate number of render targets
// On AMD PC hardware, outputting to a color index in the shader without a matching render target set has a significant performance hit
if (NumClearColors <= 1)
{
TShaderMapRef<TOneColorPixelShaderMRT<1> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 2)
{
TShaderMapRef<TOneColorPixelShaderMRT<2> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 3)
{
TShaderMapRef<TOneColorPixelShaderMRT<3> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 4)
{
TShaderMapRef<TOneColorPixelShaderMRT<4> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 5)
{
TShaderMapRef<TOneColorPixelShaderMRT<5> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 6)
{
TShaderMapRef<TOneColorPixelShaderMRT<6> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 7)
{
TShaderMapRef<TOneColorPixelShaderMRT<7> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
else if (NumClearColors == 8)
{
TShaderMapRef<TOneColorPixelShaderMRT<8> > MRTPixelShader(ShaderMap);
PixelShader = *MRTPixelShader;
}
SetGlobalBoundShaderState(RHICmdList, FeatureLevel, GClearMRTBoundShaderState[FMath::Max(NumClearColors - 1, 0)], GetVertexDeclarationFVector4(), *VertexShader, PixelShader);
FLinearColor ShaderClearColors[MaxSimultaneousRenderTargets];
FMemory::Memzero(ShaderClearColors);
for (int32 i = 0; i < NumClearColors; i++)
{
ShaderClearColors[i] = ClearColorArray[i];
}
SetShaderValueArray(RHICmdList, PixelShader->GetPixelShader(),PixelShader->ColorParameter,ShaderClearColors,NumClearColors);
{
// Draw a fullscreen quad
/*if(ExcludeRect.Width() > 0 && ExcludeRect.Height() > 0)
{
// with a hole in it (optimization in case the hardware has non constant clear performance)
FVector4 OuterVertices[4];
OuterVertices[0].Set( -1.0f, 1.0f, Depth, 1.0f );
OuterVertices[1].Set( 1.0f, 1.0f, Depth, 1.0f );
OuterVertices[2].Set( 1.0f, -1.0f, Depth, 1.0f );
OuterVertices[3].Set( -1.0f, -1.0f, Depth, 1.0f );
float InvViewWidth = 1.0f / Viewport.Width;
float InvViewHeight = 1.0f / Viewport.Height;
FVector4 FractionRect = FVector4(ExcludeRect.Min.X * InvViewWidth, ExcludeRect.Min.Y * InvViewHeight, (ExcludeRect.Max.X - 1) * InvViewWidth, (ExcludeRect.Max.Y - 1) * InvViewHeight);
FVector4 InnerVertices[4];
InnerVertices[0].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.X), FMath::Lerp(1.0f, -1.0f, FractionRect.Y), Depth, 1.0f );
InnerVertices[1].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.Z), FMath::Lerp(1.0f, -1.0f, FractionRect.Y), Depth, 1.0f );
InnerVertices[2].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.Z), FMath::Lerp(1.0f, -1.0f, FractionRect.W), Depth, 1.0f );
InnerVertices[3].Set( FMath::Lerp(-1.0f, 1.0f, FractionRect.X), FMath::Lerp(1.0f, -1.0f, FractionRect.W), Depth, 1.0f );
FVector4 Vertices[10];
Vertices[0] = OuterVertices[0];
Vertices[1] = InnerVertices[0];
Vertices[2] = OuterVertices[1];
Vertices[3] = InnerVertices[1];
Vertices[4] = OuterVertices[2];
Vertices[5] = InnerVertices[2];
Vertices[6] = OuterVertices[3];
Vertices[7] = InnerVertices[3];
Vertices[8] = OuterVertices[0];
Vertices[9] = InnerVertices[0];
DrawPrimitiveUP(RHICmdList, PT_TriangleStrip, 8, Vertices, sizeof(Vertices[0]) );
}
else*/
{
// without a hole
FVector4 Vertices[4];
Vertices[0].Set( -1.0f, 1.0f, Depth, 1.0f );
Vertices[1].Set( 1.0f, 1.0f, Depth, 1.0f );
Vertices[2].Set( -1.0f, -1.0f, Depth, 1.0f );
Vertices[3].Set( 1.0f, -1.0f, Depth, 1.0f );
DrawPrimitiveUP(RHICmdList, PT_TriangleStrip, 2, Vertices, sizeof(Vertices[0]));
}
}
}
