//---------------------------------------------------------------------------- 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); }