//----------------------------------------------------------------------------
Shader* FxCompiler::CreateShader (bool isVShader, const Program& program,
InputArray& inputs, OutputArray& outputs, ConstantArray& constants,
SamplerArray& samplers)
{
int numInputs = (int)inputs.size();
int numOutputs = (int)outputs.size();
int numConstants = (int)constants.size();
int numSamplers = (int)samplers.size();
Shader* shader;
if (isVShader)
{
shader = new0 VertexShader(program.Name, numInputs, numOutputs,
numConstants, numSamplers, true);
}
else
{
shader = new0 PixelShader(program.Name, numInputs, numOutputs,
numConstants, numSamplers, true);
}
int i;
for (i = 0; i < numInputs; ++i)
{
Input& input = inputs[i];
shader->SetInput(i, input.Name, input.Type, input.Semantic);
}
for (i = 0; i < numOutputs; ++i)
{
Output& output = outputs[i];
shader->SetOutput(i, output.Name, output.Type, output.Semantic);
}
for (i = 0; i < numConstants; ++i)
{
Constant& constant = constants[i];
shader->SetConstant(i, constant.Name, constant.NumRegistersUsed);
shader->SetBaseRegister(mActiveProfile, i, constant.BaseRegister);
}
for (i = 0; i < numSamplers; ++i)
{
Sampler& sampler = samplers[i];
shader->SetSampler(i, sampler.Name, sampler.Type);
shader->SetFilter(i, sampler.Filter);
shader->SetCoordinate(i, 0, sampler.Coordinate[0]);
shader->SetCoordinate(i, 1, sampler.Coordinate[1]);
shader->SetCoordinate(i, 2, sampler.Coordinate[2]);
shader->SetLodBias(i, sampler.LodBias);
shader->SetAnisotropy(i, sampler.Anisotropy);
shader->SetBorderColor(i, sampler.BorderColor);
shader->SetTextureUnit(mActiveProfile, i, sampler.Unit);
}
shader->SetProgram(mActiveProfile, program.Text);
return shader;
}
void FRCPassPostProcessHistogramReduce::Process(FRenderingCompositePassContext& Context)
{
SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessHistogramReduce);
const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);
if(!InputDesc)
{
// input is not hooked up correctly
return;
}
const FSceneView& View = Context.View;
const FSceneViewFamily& ViewFamily = *(View.Family);
FIntPoint SrcSize = InputDesc->Extent;
FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;
const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);
// Set the view family's render target/viewport.
SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());
// set the state
Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());
Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessHistogramReducePS> PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
// we currently assume the input is half res, one full res pixel less to avoid getting bilinear filtered input
FIntPoint GatherExtent = (View.ViewRect.Size() - FIntPoint(1, 1)) / 2;
uint32 LoopSizeValue = ComputeLoopSize(GatherExtent);
PixelShader->SetPS(Context, LoopSizeValue);
DrawPostProcessPass(
Context.RHICmdList,
0, 0,
DestSize.X, DestSize.Y,
0, 0,
SrcSize.X, 0,
DestSize,
SrcSize,
*VertexShader,
View.StereoPass,
Context.HasHmdMesh(),
EDRF_UseTriangleOptimization);
Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());
}
// If bfullResourceResolve is true: A no-op draw call is submitted which resolves all pending states
// If bFullResourceResolve is false, A no-op clear is submitted which resolves RT's only
static void ResolvePendingRenderTarget(FRHICommandListImmediate& RHICmdList, IRendererModule* RendererModule, bool bFullResourceResolve = true)
{
#if GOOGLEVRHMD_SUPPORTED_PLATFORMS
// HACK! Need to workaround UE4's caching mechanism. This causes the pending commands to actually apply to the device.
class FFakeIndexBuffer : public FIndexBuffer
{
public:
/** Initialize the RHI for this rendering resource */
void InitRHI() override
{
// Indices 0 - 5 are used for rendering a quad. Indices 6 - 8 are used for triangle optimization.
const uint16 Indices[] = { 0, 1, 2, 2, 1, 3, 0, 4, 5 };
TResourceArray<uint16, INDEXBUFFER_ALIGNMENT> IndexBuffer;
uint32 InternalNumIndices = ARRAY_COUNT(Indices);
IndexBuffer.AddUninitialized(InternalNumIndices);
FMemory::Memcpy(IndexBuffer.GetData(), Indices, InternalNumIndices * sizeof(uint16));
// Create index buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&IndexBuffer);
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16), IndexBuffer.GetResourceDataSize(), BUF_Static, CreateInfo);
}
};
static TGlobalResource<FFakeIndexBuffer> FakeIndexBuffer;
if(bFullResourceResolve)
{
const auto FeatureLevel = GMaxRHIFeatureLevel;
auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
TShaderMapRef<FScreenVS> VertexShader(ShaderMap);
TShaderMapRef<FScreenPS> PixelShader(ShaderMap);
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, FeatureLevel, BoundShaderState, RendererModule->GetFilterVertexDeclaration().VertexDeclarationRHI, *VertexShader, *PixelShader);
RHICmdList.DrawIndexedPrimitive(
FakeIndexBuffer.IndexBufferRHI,
PT_TriangleList,
/*BaseVertexIndex=*/ 0,
/*MinIndex=*/ 0,
/*NumVertices=*/ 0,
/*StartIndex=*/ 0,
/*NumPrimitives=*/ 0,
/*NumInstances=*/ 1
);
}
else
{
RHICmdList.ClearMRT(false, 0, nullptr, false, 0.0f, false, 0, FIntRect());
}
RHICmdList.ImmediateFlush(EImmediateFlushType::FlushRHIThread);
#endif
}
static void SetMotionBlurShaderNewTempl(const FRenderingCompositePassContext& Context)
{
TShaderMapRef< FPostProcessVS > VertexShader( Context.GetShaderMap() );
TShaderMapRef< FPostProcessMotionBlurNewPS< Quality > > PixelShader( Context.GetShaderMap() );
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
VertexShader->SetParameters(Context);
PixelShader->SetParameters(Context);
}
void FRCPassPostProcessVisualizeComplexity::Process(FRenderingCompositePassContext& Context)
{
SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessVisualizeComplexity);
const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);
if(!InputDesc)
{
// input is not hooked up correctly
return;
}
const FSceneView& View = Context.View;
const FSceneViewFamily& ViewFamily = *(View.Family);
FIntRect SrcRect = View.ViewRect;
FIntRect DestRect = View.UnscaledViewRect;
FIntPoint SrcSize = InputDesc->Extent;
const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);
// Set the view family's render target/viewport.
SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());
Context.SetViewportAndCallRHI(DestRect);
// turn off culling and blending
Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());
Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
// turn off depth reads/writes
Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
//reuse this generic vertex shader
TShaderMapRef<FShaderComplexityApplyVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FShaderComplexityApplyPS> PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState ShaderComplexityBoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), ShaderComplexityBoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context, Colors);
DrawRectangle(
Context.RHICmdList,
0, 0,
DestRect.Width(), DestRect.Height(),
SrcRect.Min.X, SrcRect.Min.Y,
SrcRect.Width(), SrcRect.Height(),
DestRect.Size(),
SrcSize,
*VertexShader,
EDRF_UseTriangleOptimization);
Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());
}
void FRCPassPostProcessVisualizeBuffer::SetShaderTempl(const FRenderingCompositePassContext& Context)
{
TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());
TShaderMapRef<FPostProcessVisualizeBufferPS<bDrawingTile> > PixelShader(GetGlobalShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetPS(Context);
}
SHADER_PARAM_HANDLE CShaderProgramDX9::GetHandleByName(IZ_PCSTR name)
{
IZ_ASSERT(IsValid());
SHADER_PARAM_HANDLE ret;
ret.vsParam = VertexShader()->GetHandleByName(name);
ret.psParam = PixelShader()->GetHandleByName(name);
return ret;
}
void SetSubsurfaceSetupShader(const FRenderingCompositePassContext& Context)
{
TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessSubsurfaceSetupPS<HalfRes> > PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context);
VertexShader->SetParameters(Context);
}
void FOculusRiftHMD::CopyTexture_RenderThread(FRHICommandListImmediate& RHICmdList, FTexture2DRHIParamRef DstTexture, FTexture2DRHIParamRef SrcTexture,
FIntRect DstRect, FIntRect SrcRect) const
{
check(IsInRenderingThread());
if (DstRect.IsEmpty())
{
DstRect = FIntRect(0, 0, DstTexture->GetSizeX(), DstTexture->GetSizeY());
}
const uint32 ViewportWidth = DstRect.Width();
const uint32 ViewportHeight = DstRect.Height();
const FIntPoint TargetSize(ViewportWidth, ViewportHeight);
const float SrcTextureWidth = SrcTexture->GetSizeX();
const float SrcTextureHeight = SrcTexture->GetSizeY();
float U = 0.f, V = 0.f, USize = 1.f, VSize = 1.f;
if (!SrcRect.IsEmpty())
{
U = SrcRect.Min.X / SrcTextureWidth;
V = SrcRect.Min.Y / SrcTextureHeight;
USize = SrcRect.Width() / SrcTextureWidth;
VSize = SrcRect.Height() / SrcTextureHeight;
}
SetRenderTarget(RHICmdList, DstTexture, FTextureRHIRef());
RHICmdList.SetViewport(DstRect.Min.X, DstRect.Min.Y, 0, DstRect.Max.X, DstRect.Max.Y, 1.0f);
RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
const auto FeatureLevel = GMaxRHIFeatureLevel;
auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
TShaderMapRef<FScreenVS> VertexShader(ShaderMap);
TShaderMapRef<FScreenPS> PixelShader(ShaderMap);
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, FeatureLevel, BoundShaderState, RendererModule->GetFilterVertexDeclaration().VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(RHICmdList, TStaticSamplerState<SF_Bilinear>::GetRHI(), SrcTexture);
RendererModule->DrawRectangle(
RHICmdList,
0, 0,
ViewportWidth, ViewportHeight,
U, V,
USize, VSize,
TargetSize,
FIntPoint(1, 1),
*VertexShader,
EDRF_Default);
}
//==============================================================================
VertexShader * CGraphicsMgr::FindVertexShaderRaii (const std::wstring & name) {
VertexShader * result = FindVertexShader(name);
if (!result) {
m_vertexShaders.push_back(VertexShader());
result = &m_vertexShaders.back();
}
return result;
}
void SetNoiseBlurShader(const FRenderingCompositePassContext& Context, float InRadius)
{
TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());
TShaderMapRef<FPostProcessNoiseBlurPS<Method> > PixelShader(GetGlobalShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context, InRadius);
VertexShader->SetParameters(Context);
}
/** Sets the bound shader state for either the per-pixel or per-sample fog pass. */
void SetFogShaders(FRHICommandList& RHICmdList, FScene* Scene, const FViewInfo& View, FLightShaftsOutput LightShaftsOutput)
{
if (Scene->ExponentialFogs.Num() > 0)
{
TShaderMapRef<FHeightFogVS> VertexShader(View.ShaderMap);
TShaderMapRef<FExponentialHeightFogPS> ExponentialHeightFogPixelShader(View.ShaderMap);
SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), ExponentialBoundShaderState, GFogVertexDeclaration.VertexDeclarationRHI, *VertexShader, *ExponentialHeightFogPixelShader);
VertexShader->SetParameters(RHICmdList, View);
ExponentialHeightFogPixelShader->SetParameters(RHICmdList, View, LightShaftsOutput);
}
}
void SetSubsurfaceSetupShader(const FRenderingCompositePassContext& Context)
{
TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());
TShaderMapRef<FPostProcessSubsurfaceSetupPS<SpecularCorrection> > PixelShader(GetGlobalShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context);
VertexShader->SetParameters(Context);
}
static void SetSelectionOutlineShaderTempl(const FRenderingCompositePassContext& Context)
{
TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessSelectionOutlinePS<MSAASampleCount> > PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetPS(Context);
}
bool RenderPreStencil(FRenderingCompositePassContext& Context, const FMaterialShaderMap* MaterialShaderMap, const FMatrix& ComponentToWorldMatrix, const FMatrix& FrustumComponentToClip)
{
const FSceneView& View = Context.View;
float Distance = (View.ViewMatrices.ViewOrigin - ComponentToWorldMatrix.GetOrigin()).Size();
float Radius = ComponentToWorldMatrix.GetMaximumAxisScale();
// if not inside
if(Distance > Radius)
{
float EstimatedDecalSize = Radius / Distance;
float StencilSizeThreshold = CVarStencilSizeThreshold.GetValueOnRenderThread();
// Check if it's large enough on screen
if(EstimatedDecalSize < StencilSizeThreshold)
{
return false;
}
}
TShaderMapRef<FDeferredDecalVS> VertexShader(Context.GetShaderMap());
Context.RHICmdList.SetLocalBoundShaderState(Context.RHICmdList.BuildLocalBoundShaderState(GetVertexDeclarationFVector3(), VertexShader->GetVertexShader(), FHullShaderRHIRef(), FDomainShaderRHIRef(), NULL, FGeometryShaderRHIRef()));
VertexShader->SetParameters(Context.RHICmdList, View, FrustumComponentToClip);
// Set states, the state cache helps us avoiding redundant sets
Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());
// all the same to have DX10 working
Context.RHICmdList.SetBlendState(TStaticBlendState<
CW_NONE, BO_Add, BF_SourceAlpha, BF_InverseSourceAlpha, BO_Add, BF_Zero, BF_One, // Emissive
CW_NONE, BO_Add, BF_SourceAlpha, BF_InverseSourceAlpha, BO_Add, BF_Zero, BF_One, // Normal
CW_NONE, BO_Add, BF_SourceAlpha, BF_InverseSourceAlpha, BO_Add, BF_Zero, BF_One, // Metallic, Specular, Roughness
CW_NONE, BO_Add, BF_SourceAlpha, BF_InverseSourceAlpha, BO_Add, BF_Zero, BF_One // BaseColor
>::GetRHI() );
// Carmack's reverse on the bounds
//@todo-martinm
Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_LessEqual,
true,CF_Equal,SO_Keep,SO_Keep,SO_Increment,
true,CF_Equal,SO_Keep,SO_Keep,SO_Decrement,
0x80,0x7f
>::GetRHI());
// Render decal mask
Context.RHICmdList.DrawIndexedPrimitive(GUnitCubeIndexBuffer.IndexBufferRHI, PT_TriangleList, 0, 0, 8, 0, GUnitCubeIndexBuffer.GetIndexCount() / 3, 1);
return true;
}
void FDecalRendering::SetShader(FRHICommandList& RHICmdList, const FViewInfo& View, const FTransientDecalRenderData& DecalData, const FMatrix& FrustumComponentToClip)
{
const FMaterialShaderMap* MaterialShaderMap = DecalData.MaterialResource->GetRenderingThreadShaderMap();
auto PixelShader = MaterialShaderMap->GetShader<FDeferredDecalPS>();
TShaderMapRef<FDeferredDecalVS> VertexShader(View.ShaderMap);
const EDebugViewShaderMode DebugViewShaderMode = View.Family->GetDebugViewShaderMode();
if (DebugViewShaderMode != DVSM_None)
{
// For this to work, decal VS must output compatible interpolants. Currently this requires to use FDebugPSInLean.
// Here we pass nullptr for the material interface because the use of a static bound shader state is only compatible with unique shaders.
IDebugViewModePSInterface* DebugPixelShader = FDebugViewMode::GetPSInterface(View.ShaderMap, nullptr, DebugViewShaderMode);
const uint32 NumPixelShaderInstructions = PixelShader->GetNumInstructions();
const uint32 NumVertexShaderInstructions = VertexShader->GetNumInstructions();
static FGlobalBoundShaderState BoundShaderState[DVSM_MAX];
SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), BoundShaderState[(uint32)DebugViewShaderMode], GetVertexDeclarationFVector4(), *VertexShader, DebugPixelShader->GetShader());
DebugPixelShader->SetParameters(RHICmdList, *VertexShader, PixelShader, DecalData.MaterialProxy, *DecalData.MaterialResource, View);
DebugPixelShader->SetMesh(RHICmdList, View);
}
else
{
// first Bind, then SetParameters()
RHICmdList.SetLocalBoundShaderState(RHICmdList.BuildLocalBoundShaderState(GetVertexDeclarationFVector4(), VertexShader->GetVertexShader(), FHullShaderRHIRef(), FDomainShaderRHIRef(), PixelShader->GetPixelShader(), FGeometryShaderRHIRef()));
PixelShader->SetParameters(RHICmdList, View, DecalData.MaterialProxy, *DecalData.DecalProxy, DecalData.FadeAlpha);
}
// SetUniformBufferParameter() need to happen after the shader has been set otherwise a DebugBreak could occur.
// we don't have the Primitive uniform buffer setup for decals (later we want to batch)
{
auto& PrimitiveVS = VertexShader->GetUniformBufferParameter<FPrimitiveUniformShaderParameters>();
auto& PrimitivePS = PixelShader->GetUniformBufferParameter<FPrimitiveUniformShaderParameters>();
// uncomment to track down usage of the Primitive uniform buffer
// check(!PrimitiveVS.IsBound());
// check(!PrimitivePS.IsBound());
// to prevent potential shader error (UE-18852 ElementalDemo crashes due to nil constant buffer)
SetUniformBufferParameter(RHICmdList, VertexShader->GetVertexShader(), PrimitiveVS, GIdentityPrimitiveUniformBuffer);
if (DebugViewShaderMode == DVSM_None)
{
SetUniformBufferParameter(RHICmdList, PixelShader->GetPixelShader(), PrimitivePS, GIdentityPrimitiveUniformBuffer);
}
}
VertexShader->SetParameters(RHICmdList, View, FrustumComponentToClip);
}
void FRCPassPostProcessBokehDOFRecombine::SetShader(const FRenderingCompositePassContext& Context)
{
TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessBokehDOFRecombinePS<Method> > PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context);
VertexShader->SetParameters(Context);
}
void FIESLightProfileBatchedElementParameters::BindShaders( FRHICommandList& RHICmdList, ERHIFeatureLevel::Type InFeatureLevel, const FMatrix& InTransform, const float InGamma, const FMatrix& ColorWeights, const FTexture* Texture )
{
TShaderMapRef<FSimpleElementVS> VertexShader(GetGlobalShaderMap(InFeatureLevel));
TShaderMapRef<FIESLightProfilePS> PixelShader(GetGlobalShaderMap(InFeatureLevel));
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, InFeatureLevel, BoundShaderState, GSimpleElementVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
VertexShader->SetParameters(RHICmdList, InTransform);
PixelShader->SetParameters(RHICmdList, Texture, BrightnessInLumens);
}
void FRCPassPostProcessDownsample::SetShader(const FRenderingCompositePassContext& Context, const FPooledRenderTargetDesc* InputDesc)
{
auto ShaderMap = Context.GetShaderMap();
TShaderMapRef<FPostProcessDownsampleVS> VertexShader(ShaderMap);
TShaderMapRef<FPostProcessDownsamplePS<Method> > PixelShader(ShaderMap);
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context, InputDesc);
VertexShader->SetParameters(Context);
}
void FRCPassPostProcessSceneColorFringe::Process(FRenderingCompositePassContext& Context)
{
SCOPED_DRAW_EVENT(Context.RHICmdList, SceneColorFringe);
const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);
if(!InputDesc)
{
// input is not hooked up correctly
return;
}
const FSceneView& View = Context.View;
const FSceneViewFamily& ViewFamily = *(View.Family);
const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);
// Set the view family's render target/viewport.
SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());
Context.SetViewportAndCallRHI(View.ViewRect);
// set the state
Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());
Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
TShaderMapRef<FPostProcessSceneColorFringeVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessSceneColorFringePS> PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(Context);
VertexShader->SetParameters(Context);
// Draw a quad mapping scene color to the view's render target
DrawRectangle(
Context.RHICmdList,
0, 0,
View.ViewRect.Width(), View.ViewRect.Height(),
View.ViewRect.Min.X, View.ViewRect.Min.Y,
View.ViewRect.Width(), View.ViewRect.Height(),
View.ViewRect.Size(),
FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY(),
*VertexShader,
EDRF_UseTriangleOptimization);
Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());
}
void PrefilterPlanarReflection(FRHICommandListImmediate& RHICmdList, FViewInfo& View, const FPlanarReflectionSceneProxy* ReflectionSceneProxy, const FRenderTarget* Target)
{
FTextureRHIParamRef SceneColorInput = FSceneRenderTargets::Get(RHICmdList).GetSceneColorTexture();
if(View.FeatureLevel >= ERHIFeatureLevel::SM4)
{
// Note: null velocity buffer, so dynamic object temporal AA will not be correct
TRefCountPtr<IPooledRenderTarget> VelocityRT;
TRefCountPtr<IPooledRenderTarget> FilteredSceneColor;
GPostProcessing.ProcessPlanarReflection(RHICmdList, View, VelocityRT, FilteredSceneColor);
if (FilteredSceneColor)
{
SceneColorInput = FilteredSceneColor->GetRenderTargetItem().ShaderResourceTexture;
}
}
{
SCOPED_DRAW_EVENT(RHICmdList, PrefilterPlanarReflection);
FRHIRenderTargetView ColorView(Target->GetRenderTargetTexture(), 0, -1, ERenderTargetLoadAction::ENoAction, ERenderTargetStoreAction::EStore);
FRHISetRenderTargetsInfo Info(1, &ColorView, FRHIDepthRenderTargetView());
RHICmdList.SetRenderTargetsAndClear(Info);
RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
TShaderMapRef<TDeferredLightVS<false> > VertexShader(View.ShaderMap);
TShaderMapRef<FPrefilterPlanarReflectionPS<bEnablePlanarReflectionPrefilter> > PixelShader(View.ShaderMap);
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetParameters(RHICmdList, View, ReflectionSceneProxy, SceneColorInput);
VertexShader->SetSimpleLightParameters(RHICmdList, View, FSphere(0));
DrawRectangle(
RHICmdList,
0, 0,
View.ViewRect.Width(), View.ViewRect.Height(),
View.ViewRect.Min.X, View.ViewRect.Min.Y,
View.ViewRect.Width(), View.ViewRect.Height(),
View.ViewRect.Size(),
FSceneRenderTargets::Get(RHICmdList).GetBufferSizeXY(),
*VertexShader,
EDRF_UseTriangleOptimization);
}
}
FShader* FRCPassPostProcessVisualizeBuffer::SetShaderTempl(const FRenderingCompositePassContext& Context)
{
TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessVisualizeBufferPS<bDrawingTile> > PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetPS(Context);
return *VertexShader;
}
void FRCPassPostProcessHMD::Process(FRenderingCompositePassContext& Context)
{
SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessHMD, DEC_SCENE_ITEMS);
const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);
if(!InputDesc)
{
// input is not hooked up correctly
return;
}
const FSceneView& View = Context.View;
const FSceneViewFamily& ViewFamily = *(View.Family);
const FIntRect SrcRect = View.ViewRect;
const FIntRect DestRect = View.UnscaledViewRect;
const FIntPoint SrcSize = InputDesc->Extent;
const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);
// Set the view family's render target/viewport.
SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());
Context.SetViewportAndCallRHI(DestRect);
Context.RHICmdList.Clear(true, FLinearColor::Black, false, 1.0f, false, 0, FIntRect());
// set the state
Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());
Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
FMatrix QuadTexTransform = FMatrix::Identity;
FMatrix QuadPosTransform = FMatrix::Identity;
check(GEngine->HMDDevice.IsValid());
{
TShaderMapRef<FPostProcessHMDVS<false> > VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessHMDPS<false> > PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GDistortionVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
VertexShader->SetVS(Context, View.StereoPass);
PixelShader->SetPS(Context, SrcRect, SrcSize, View.StereoPass, QuadTexTransform);
}
GEngine->HMDDevice->DrawDistortionMesh_RenderThread(Context, View, SrcSize);
Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());
}
void FMipLevelBatchedElementParameters::BindShaders(FRHICommandList& RHICmdList, ERHIFeatureLevel::Type InFeatureLevel, const FMatrix& InTransform, const float InGamma, const FMatrix& ColorWeights, const FTexture* Texture)
{
TShaderMapRef<FCubemapTexturePropertiesVS> VertexShader(GetGlobalShaderMap(InFeatureLevel));
TShaderMapRef<TPixelShader> PixelShader(GetGlobalShaderMap(InFeatureLevel));
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, InFeatureLevel, BoundShaderState, GSimpleElementVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
VertexShader->SetParameters(RHICmdList, InTransform);
RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
PixelShader->SetParameters(RHICmdList, Texture, ColorWeights, MipLevel, InGamma);
}
bool Rasterizer::VInit(DXDriver* _driver)
{
if (m_pVertexShaderStage || m_pPixelShaderStage || m_pGeometryShaderStage)
{
PrintError(AT, "shader stages already created");
return false;
}
m_pVertexShaderStage = VNEW VertexShader();
m_pGeometryShaderStage = VNEW GeometryShader();
m_pPixelShaderStage = VNEW PixelShader();
if (!m_pVertexShaderStage->Init(L"Assets/Shaders/RasterNodeVS.hlsl", _driver->GetDevice()))
//if (!m_pVertexShaderStage->Init(L"Assets/Shaders/vtest.hlsl", _driver->GetDevice()))
{
PrintError(AT, "failed to create vertex shader stage");
return false;
}
if (!m_pGeometryShaderStage->Init(L"Assets/Shaders/RasterNodeGS.hlsl", _driver->GetDevice()))
//if (!m_pGeometryShaderStage->Init(L"Assets/Shaders/gtest.hlsl", _driver->GetDevice()))
{
PrintError(AT, "failed to create geometry shader stage");
return false;
}
if (!m_pPixelShaderStage->Init(L"Assets/Shaders/RasterNodePS.hlsl", _driver->GetDevice()))
//if (!m_pPixelShaderStage->Init(L"Assets/Shaders/ptest.hlsl", _driver->GetDevice()))
{
PrintError(AT, "failed to create pixel shader stage");
return false;
}
RenderTarget* renderTarget = nullptr;
for (unsigned int i = RT_COLOR; i < RENDERTARGET_COUNT; ++i)
{
_driver->GetRenderTarget(i, renderTarget);
if (!renderTarget)
return false;
renderTarget->GetView(m_pDeferredRenderTargets[i]);
if (!m_pDeferredRenderTargets[i])
return false;
}
return true;
}
static void ResolveColorWideInternal2(
FRHICommandList& RHICmdList,
const ERHIFeatureLevel::Type CurrentFeatureLevel,
const FTextureRHIRef& SrcTexture,
const FIntPoint& SrcOrigin)
{
auto ShaderMap = GetGlobalShaderMap(CurrentFeatureLevel);
TShaderMapRef<FWideCustomResolveVS> VertexShader(ShaderMap);
TShaderMapRef<FWideCustomResolvePS<MSAA, Width>> PixelShader(ShaderMap);
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, CurrentFeatureLevel, BoundShaderState, GetVertexDeclarationFVector4(), *VertexShader, *PixelShader);
PixelShader->SetParameters(RHICmdList, SrcTexture, SrcOrigin);
RHICmdList.DrawPrimitive(PT_TriangleList, 0, 1, 1);
}
void FRCPassPostProcessEyeAdaptation::Process(FRenderingCompositePassContext& Context)
{
SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessEyeAdaptation, DEC_SCENE_ITEMS);
const FSceneView& View = Context.View;
const FSceneViewFamily& ViewFamily = *(View.Family);
IPooledRenderTarget* EyeAdaptation = Context.View.GetEyeAdaptation();
check(EyeAdaptation);
FIntPoint DestSize = EyeAdaptation->GetDesc().Extent;
// we render to our own output render target, not the intermediate one created by the compositing system
// Set the view family's render target/viewport.
SetRenderTarget(Context.RHICmdList, EyeAdaptation->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());
Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );
// set the state
Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());
Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());
TShaderMapRef<FPostProcessEyeAdaptationPS> PixelShader(Context.GetShaderMap());
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
PixelShader->SetPS(Context);
// Draw a quad mapping scene color to the view's render target
DrawRectangle(
Context.RHICmdList,
0, 0,
DestSize.X, DestSize.Y,
0, 0,
DestSize.X, DestSize.Y,
DestSize,
DestSize,
*VertexShader,
EDRF_UseTriangleOptimization);
Context.RHICmdList.CopyToResolveTarget(EyeAdaptation->GetRenderTargetItem().TargetableTexture, EyeAdaptation->GetRenderTargetItem().ShaderResourceTexture, false, FResolveParams());
}
/** Binds the mesh paint vertex and pixel shaders to the graphics device */
void SetMeshPaintDilateShaders(FRHICommandList& RHICmdList, ERHIFeatureLevel::Type InFeatureLevel, const FMatrix& InTransform,
const float InGamma,
const FMeshPaintDilateShaderParameters& InShaderParams )
{
TShaderMapRef< TMeshPaintDilateVertexShader > VertexShader(GetGlobalShaderMap(InFeatureLevel));
TShaderMapRef< TMeshPaintDilatePixelShader > PixelShader(GetGlobalShaderMap(InFeatureLevel));
static FGlobalBoundShaderState BoundShaderState;
SetGlobalBoundShaderState(RHICmdList, InFeatureLevel, BoundShaderState, GMeshPaintDilateVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);
// Set vertex shader parameters
VertexShader->SetParameters(RHICmdList, InTransform );
// Set pixel shader parameters
PixelShader->SetParameters(RHICmdList, InGamma, InShaderParams );
}
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.
}
}
}
static Program make_prog(void)
{
Program prog(ObjectDesc("Screen"));
prog.AttachShader(VertexShader(
ObjectDesc("Screen vertex"),
StrLit(
"#version 330\n"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Position;"
" vertTexCoord = TexCoord;"
"}"
)
)).AttachShader(FragmentShader(
ObjectDesc("Screen fragment"),
StrLit(
"#version 330\n"
"uniform sampler2D Background, NormalMap;"
"in vec2 vertTexCoord;"
"out vec3 fragColor;"
"void main(void)"
"{"
" vec4 nm = texture(NormalMap, vertTexCoord);"
" vec2 offs = nm.xy*0.05+vec2(0.004, 0.004)*nm.w;"
" vec4 c = texture(Background, vertTexCoord+offs);"
" float l = clamp(nm.w+pow(dot(nm.xy,vec2(0.2,0.2)), 9.0), 0.3, 1.1);"
" fragColor = c.rgb*mix(1.2, 0.8, l);"
"}"
)
)).Link().Use();
return std::move(prog);
}
