UE4 自定义Shader 和 RHI

UE4 自定义Shader 和 RHI

使用UE4自定义Shader和RHI绘制简单三角形，参考上一节创建RenderTarget来显示三角形。

创建shader

使用UE4创建自定义shader需要注释掉(Engine / Config / ConsoleVariables.ini)
r.ShaderDevelopmentMode = 1

Plugins\TPViewport\Shaders\Private\SimpleShader.usf

#include "/Engine/Public/Platform.ush"
//顶点着色器
/*
	输入二维点和颜色；
	输出四维的点和颜色。
*/
void MainVS(
	in float2 InPosition : ATTRIBUTE0,
	in float4 InColor : ATTRIBUTE1,
	out float4 OutPosition : SV_POSITION,
	out float4 OutColor : COLOR0
	)
{
	OutPosition = float4(InPosition, 0, 1);
	OutColor = InColor;
}
//像素着色器
//输入顶点和颜色
//输出颜色
void MainPS(
	in float4 InPosition : SV_POSITION,
	in float4 InColor : COLOR0,
	out float4 OutColor : SV_Target0)
{
	OutColor = InColor;
}

创建模块Renderer

在插件中手动创建SimpleRender模块。
\Plugins\TPViewport\Source\SimpleRender\SimpleRenderer.Build.cs

using UnrealBuildTool;

public class SimpleRenderer : ModuleRules
{
	public SimpleRenderer(ReadOnlyTargetRules Target) : base(Target)
	{
		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
		
		PublicIncludePaths.AddRange(
			new  string []
    			{
			}
		);
		
		PrivateIncludePaths . AddRange (
			new  string []
      			{
			}
		);
    
		PublicDependencyModuleNames.AddRange(
			new  string []
			{
                		"Core",
                		"CoreUObject",
	             		"Engine",
        	        	"RenderCore",
                		"Projects",
	                	"RHI"
      			}
		);
    
		PrivateDependencyModuleNames.AddRange(
			new  string []
			{
			}
		);
		
		DynamicallyLoadedModuleNames.AddRange(
			new  string []
			{
			}
		);
	}
}

Plugins\TPViewport\Source\SimpleRender\Private\SimpleRenderer.h

# pragma once

#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"

class FSimpleRendererModule : public IModuleInterface
{
public:
	virtual void StartupModule() override;
	virtual void ShutdownModule() override;

};

Plugins\TPViewport\Source\SimpleRender\Private\SimpleRenderer.cpp
模块启动时，设置shader的映射路径。

void FSimpleRendererModule::StartupModule()
{
	FString PluginShaderDir = FPaths::Combine(IPluginManager::Get().FindPlugin(TEXT("TPViewport"))->GetBaseDir(), TEXT("Shaders"));
	AddShaderSourceDirectoryMapping(TEXT("/Plugin/TPViewport"), PluginShaderDir);
}

void FSimpleRendererModule::ShutdownModule()
{
}

Plugins\TPViewport\Source\SimpleRender\Public\SimpleShader.h
分别创建顶点和像素shader的映射类。

# pragma once

#include "CoreMinimal.h"
#include "GlobalShader.h"

class FSimpleShader : public FGlobalShader
{
public:
	FSimpleShader() {}

	FSimpleShader(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
		: FGlobalShader(Initializer) {}

	static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
	{
		return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);
	}
};
//顶点shader
class FSimpleShaderVS : public FSimpleShader
{
	DECLARE_SHADER_TYPE(FSimpleShaderVS, Global);
public:
	FSimpleShaderVS() {}

	FSimpleShaderVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
		: FSimpleShader(Initializer)
	{
	}
};
//像素shader
class FSimpleShaderPS : public FSimpleShader
{
	DECLARE_SHADER_TYPE(FSimpleShaderPS, Global);
public:
	FSimpleShaderPS() {}

	FSimpleShaderPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
		: FSimpleShader(Initializer)
	{
	}
};
//辅助类供外部调用
class SIMPLERENDERER_API FSimpleRenderer
{
public:
	FSimpleRenderer () {};

	void  Render ( class  UTextureRenderTarget2D * RenderTarget);
};

Plugins\TPViewport\Source\SimpleRender\Private\SimpleShader.cpp

#include "SimpleShader.h"

#include "Containers/DynamicRHIResourceArray.h"
#include "TextureResource.h"
#include "Engine/TextureRenderTarget2D.h"
#include "RHIStaticStates.h"
#include "PipelineStateCache.h"

//映射C++与Shader
IMPLEMENT_SHADER_TYPE(, FSimpleShaderVS, TEXT("/Plugin/TPViewport/Private/SimpleShader.usf"), TEXT("MainVS"), SF_Vertex)
IMPLEMENT_SHADER_TYPE(, FSimpleShaderPS, TEXT("/Plugin/TPViewport/Private/SimpleShader.usf"), TEXT("MainPS"), SF_Pixel)
//顶点shader输入
struct FColorVertex {
	FVector2D Position;
	FVector4 Color;
};
//顶点缓冲区
class FSimpleVertexBuffer : public FVertexBuffer
{
public:
	void InitRHI() override
	{
		TResourceArray<FColorVertex, VERTEXBUFFER_ALIGNMENT> Vertices;
		Vertices. SetNumUninitialized ( 3 );

		Vertices[0].Position = FVector2D(0, 0.75);
		Vertices[0].Color = FVector4(1, 0, 0, 1);

		Vertices[1].Position = FVector2D(0.75, -0.75);
		Vertices[1].Color = FVector4(0, 1, 0, 1);

		Vertices[2].Position = FVector2D(-0.75, -0.75);
		Vertices[2].Color = FVector4(0, 0, 1, 1);
    
		FRHIResourceCreateInfo CreateInfo(&Vertices);
		VertexBufferRHI = RHICreateVertexBuffer(Vertices.GetResourceDataSize(), BUF_Static, CreateInfo);
	}
};

TGlobalResource<FSimpleVertexBuffer> GSimpleVertexBuffer;
//顶点缓冲区属性描述
class FColorVertexDeclaration : public FRenderResource
{
public:
	FVertexDeclarationRHIRef VertexDeclarationRHI;
	virtual void InitRHI() override
	{
		FVertexDeclarationElementList Elements;
		uint32 Stride = sizeof(FColorVertex);
		Elements.Add(FVertexElement(0, STRUCT_OFFSET(FColorVertex, Position), VET_Float2, 0, Stride));
		Elements.Add(FVertexElement(0, STRUCT_OFFSET(FColorVertex, Color), VET_Float4, 1, Stride));
		VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
	}
	virtual void ReleaseRHI() override
	{
		VertexDeclarationRHI.SafeRelease();
	}
};

TGlobalResource<FColorVertexDeclaration> GSimpleVertexDeclaration;
//索引缓冲区
class FSimpleIndexBuffer : public FIndexBuffer
{
public:
	void InitRHI() override
	{
		const uint16 Indices[] = { 0, 1, 2 };

		TResourceArray <uint16, INDEXBUFFER_ALIGNMENT> IndexBuffer;
		uint32 NumIndices = ARRAY_COUNT(Indices);
		IndexBuffer. AddUninitialized (NumIndices);
		FMemory::Memcpy(IndexBuffer.GetData(), Indices, NumIndices * sizeof(uint16));

		FRHIResourceCreateInfo CreateInfo (& IndexBuffer);
		IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16), IndexBuffer.GetResourceDataSize(), BUF_Static, CreateInfo);
	}
};

TGlobalResource<FSimpleIndexBuffer> GSimpleIndexBuffer;
//绘制
static void DrawTestShaderRenderTarget_RenderThread(
	FRHICommandListImmediate& RHICmdList,
	FTextureRenderTargetResource* OutputRenderTargetResource
)
{
	check(IsInRenderingThread());

	FRHIRenderPassInfo RPInfo(OutputRenderTargetResource->GetRenderTargetTexture(), ERenderTargetActions::DontLoad_Store, OutputRenderTargetResource->TextureRHI);
	RHICmdList.BeginRenderPass(RPInfo, TEXT("SimpleRendererShaderPass"));
	{
		// Get shaders.
		FGlobalShaderMap* GlobalShaderMap = GetGlobalShaderMap(GMaxRHIFeatureLevel);
		TShaderMapRef<FSimpleShaderVS> VertexShader(GlobalShaderMap);
		TShaderMapRef<FSimpleShaderPS> PixelShader(GlobalShaderMap);

		// Set the graphic pipeline state.
		FGraphicsPipelineStateInitializer GraphicsPSOInit;
		RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
		GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
		GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
		GraphicsPSOInit.RasterizerState = TStaticRasterizerState<>::GetRHI();
		GraphicsPSOInit.PrimitiveType = PT_TriangleList;
		GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GSimpleVertexDeclaration.VertexDeclarationRHI;
		GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
		GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
		SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);

		// Update viewport.
		RHICmdList.SetViewport(
			0, 0, 0.f,
			OutputRenderTargetResource->GetSizeX(), OutputRenderTargetResource->GetSizeY(), 1.f);

		// Set the vertextBuffer.
		RHICmdList.SetStreamSource(0, GSimpleVertexBuffer.VertexBufferRHI, 0);

		RHICmdList.DrawIndexedPrimitive(
			GSimpleIndexBuffer.IndexBufferRHI,
			/*BaseVertexIndex=*/ 0,
			/* MinIndex = */  0,
			/* NumVertices = */3,
			/*StartIndex=*/0,
			/* NumPrimitives = */1,
			/*NumInstances=*/1);
	}
	RHICmdList.EndRenderPass();
}

void FSimpleRenderer::Render(UTextureRenderTarget2D* RenderTarget)
{
	check ( IsInGameThread ());

	if (!RenderTarget)
	{
		return;
	}

	FTextureRenderTargetResource * TextureRenderTargetResource = RenderTarget-> GameThread_GetRenderTargetResource ();
	//ERHIFeatureLevel::Type FeatureLevel = World->Scene->GetFeatureLevel();
	ENQUEUE_RENDER_COMMAND(CaptureCommand)(
		[TextureRenderTargetResource](FRHICommandListImmediate& RHICmdList)
		{
			DrawTestShaderRenderTarget_RenderThread(RHICmdList, TextureRenderTargetResource);
		}
	);
}

Plugins\TPViewport\Source\TPViewport\Public\RenderTestViewportClient.cpp
引入模块SimpleRender后，就可以将三角形渲染到RenderTarget。

#include "RenderTestViewportClient.h"
#include "Runtime/Engine/Public/CanvasTypes.h"
#include "Runtime/Engine/Public/CanvasItem.h"
#include "Engine/TextureRenderTarget2D.h"

#include "SimpleShader.h"

FRenderTestViewportClient::FRenderTestViewportClient()
{
	RenderTarget = NewObject<UTextureRenderTarget2D>(GetTransientPackage(), NAME_None, RF_Transient);
	RenderTarget->RenderTargetFormat = RTF_RGBA8;
	RenderTarget->InitAutoFormat(1024, 1024);
	RenderTarget->ClearColor = FLinearColor::Blue;
	RenderTarget->UpdateResource();
}

void FRenderTestViewportClient::Draw(FViewport* Viewport, FCanvas* Canvas)
{
	

	FSimpleRenderer renderer;
	renderer.Render(RenderTarget);

	//绘制RenderTarget
	FCanvasTileItem Tile(FVector2D::ZeroVector, RenderTarget->Resource, Viewport->GetSizeXY(), FLinearColor(1, 1, 1, 1));
	Canvas->DrawItem(Tile);
}

参考链接

UE4 自定义Shader 和 RHI